From 8a7cafa12bafc0a676497065fcdddc25525a36fe Mon Sep 17 00:00:00 2001
From: Leonardo de Moura <leonardo@microsoft.com>
Date: Tue, 20 Oct 2020 13:30:09 -0700
Subject: [PATCH] chore: update stage0

---
 stage0/src/Lean/Data/Json.lean                |     1 +
 stage0/src/Lean/Data/KVMap.lean               |    22 +-
 stage0/src/Lean/Data/LBool.lean               |     4 +-
 stage0/src/Lean/Data/LOption.lean             |    10 +-
 stage0/src/Lean/Data/Lsp.lean                 |     1 +
 stage0/src/Lean/Data/Name.lean                |     9 +-
 stage0/src/Lean/Data/Occurrences.lean         |     1 +
 stage0/src/Lean/Data/OpenDecl.lean            |     1 +
 stage0/src/Lean/Data/Options.lean             |    47 +-
 stage0/src/Lean/Data/Position.lean            |    58 +-
 stage0/src/Lean/Data/SMap.lean                |     1 +
 stage0/src/Lean/Data/Trie.lean                |    91 +-
 stage0/src/Lean/Message.lean                  |     3 +
 stage0/src/Lean/Util/FindExpr.lean            |    63 +-
 stage0/src/Lean/Util/FindMVar.lean            |    23 +-
 stage0/src/Lean/Util/Path.lean                |    47 +-
 stage0/src/Lean/Util/Profile.lean             |     1 +
 stage0/src/Lean/Util/RecDepth.lean            |     4 +-
 stage0/src/Lean/Util/Recognizers.lean         |     7 +-
 stage0/src/Lean/Util/SCC.lean                 |    60 +-
 stage0/src/Lean/Util/Sorry.lean               |     5 +-
 stage0/src/Std/Data/BinomialHeap.lean         |    32 +-
 stage0/src/Std/Data/DList.lean                |    21 +-
 stage0/src/Std/Data/Queue.lean                |     1 +
 stage0/src/Std/Data/RBMap.lean                |    67 +-
 stage0/stdlib/Lean/Attributes.c               |   128 +-
 stage0/stdlib/Lean/Class.c                    |   128 +-
 stage0/stdlib/Lean/Compiler/ClosedTermCache.c |    64 +-
 stage0/stdlib/Lean/Compiler/ExportAttr.c      |    18 +-
 stage0/stdlib/Lean/Compiler/ExternAttr.c      |    26 +-
 stage0/stdlib/Lean/Compiler/IR/Basic.c        | 12401 ++---
 stage0/stdlib/Lean/Compiler/IR/Borrow.c       |    14 +-
 stage0/stdlib/Lean/Compiler/IR/Checker.c      |    12 +-
 stage0/stdlib/Lean/Compiler/IR/CompilerM.c    |    68 +-
 stage0/stdlib/Lean/Compiler/IR/CtorLayout.c   |    10 +-
 .../Lean/Compiler/IR/ElimDeadBranches.c       |    64 +-
 stage0/stdlib/Lean/Compiler/IR/ElimDeadVars.c |     6 +-
 stage0/stdlib/Lean/Compiler/IR/EmitUtil.c     |    18 +-
 stage0/stdlib/Lean/Compiler/IR/Format.c       |    12 +-
 stage0/stdlib/Lean/Compiler/IR/FreeVars.c     |    50 +-
 stage0/stdlib/Lean/Compiler/IR/LiveVars.c     |  8336 ++--
 stage0/stdlib/Lean/Compiler/IR/NormIds.c      |    16 +-
 stage0/stdlib/Lean/Compiler/IR/PushProj.c     |    38 +-
 stage0/stdlib/Lean/Compiler/IR/RC.c           |  4125 +-
 .../stdlib/Lean/Compiler/ImplementedByAttr.c  |    18 +-
 stage0/stdlib/Lean/Compiler/InitAttr.c        |    18 +-
 stage0/stdlib/Lean/Compiler/InlineAttrs.c     |    30 +-
 .../stdlib/Lean/Compiler/NeverExtractAttr.c   |     4 +-
 stage0/stdlib/Lean/Compiler/Specialize.c      |   158 +-
 stage0/stdlib/Lean/Data/Json/Basic.c          |  4067 +-
 stage0/stdlib/Lean/Data/Json/Printer.c        |    12 +-
 stage0/stdlib/Lean/Data/KVMap.c               |  1373 +-
 stage0/stdlib/Lean/Data/LBool.c               |   351 +-
 stage0/stdlib/Lean/Data/LOption.c             |   195 +-
 stage0/stdlib/Lean/Data/Lsp/InitShutdown.c    |     6 +-
 stage0/stdlib/Lean/Data/Name.c                | 14004 +++---
 stage0/stdlib/Lean/Data/Occurrences.c         |   190 +-
 stage0/stdlib/Lean/Data/OpenDecl.c            |   119 +-
 stage0/stdlib/Lean/Data/Options.c             |  1326 +-
 stage0/stdlib/Lean/Data/Position.c            |   326 +-
 stage0/stdlib/Lean/Data/SMap.c                |   412 +-
 stage0/stdlib/Lean/Data/Trie.c                | 17268 +++----
 stage0/stdlib/Lean/Delaborator.c              |    28 +-
 stage0/stdlib/Lean/Elab/App.c                 |   849 +-
 stage0/stdlib/Lean/Elab/Binders.c             |     6 +-
 stage0/stdlib/Lean/Elab/BuiltinNotation.c     |    40 +-
 stage0/stdlib/Lean/Elab/Command.c             |    26 +-
 stage0/stdlib/Lean/Elab/DeclModifiers.c       |    18 +-
 stage0/stdlib/Lean/Elab/DeclUtil.c            |    12 +-
 stage0/stdlib/Lean/Elab/Do.c                  |   262 +-
 stage0/stdlib/Lean/Elab/Inductive.c           |     4 +-
 stage0/stdlib/Lean/Elab/LetRec.c              |     6 +-
 stage0/stdlib/Lean/Elab/Match.c               |    18 +-
 stage0/stdlib/Lean/Elab/MutualDef.c           |   770 +-
 stage0/stdlib/Lean/Elab/PreDefinition/Basic.c |     4 +-
 stage0/stdlib/Lean/Elab/PreDefinition/Main.c  |  1779 +-
 .../Lean/Elab/PreDefinition/Structural.c      |   534 +-
 stage0/stdlib/Lean/Elab/Quotation.c           |    48 +-
 stage0/stdlib/Lean/Elab/StrategyAttrs.c       |    26 +-
 stage0/stdlib/Lean/Elab/StructInst.c          |   958 +-
 stage0/stdlib/Lean/Elab/Structure.c           |     4 +-
 stage0/stdlib/Lean/Elab/Syntax.c              |   164 +-
 stage0/stdlib/Lean/Elab/SyntheticMVars.c      |     8 +-
 stage0/stdlib/Lean/Elab/Tactic/Basic.c        |    12 +-
 stage0/stdlib/Lean/Elab/Tactic/Induction.c    |    12 +-
 stage0/stdlib/Lean/Elab/Term.c                |     8 +-
 stage0/stdlib/Lean/Environment.c              |   671 +-
 stage0/stdlib/Lean/Expr.c                     |     8 +-
 stage0/stdlib/Lean/Hygiene.c                  |    24 +-
 stage0/stdlib/Lean/KeyedDeclsAttribute.c      |   128 +-
 stage0/stdlib/Lean/Level.c                    |     8 +-
 stage0/stdlib/Lean/Meta/AbstractMVars.c       |     4 +-
 stage0/stdlib/Lean/Meta/Basic.c               |     4 +-
 stage0/stdlib/Lean/Meta/Check.c               |     4 +-
 stage0/stdlib/Lean/Meta/DiscrTree.c           |     4 +-
 stage0/stdlib/Lean/Meta/ExprDefEq.c           |     6 +-
 stage0/stdlib/Lean/Meta/InferType.c           |    10 +-
 stage0/stdlib/Lean/Meta/LevelDefEq.c          |     6 +-
 stage0/stdlib/Lean/Meta/Match/MVarRenaming.c  |    16 +-
 stage0/stdlib/Lean/Meta/Match/Match.c         |   636 +-
 stage0/stdlib/Lean/Meta/RecursorInfo.c        |   716 +-
 stage0/stdlib/Lean/Meta/SynthInstance.c       |     4 +-
 stage0/stdlib/Lean/Meta/Tactic/Apply.c        |   426 +-
 stage0/stdlib/Lean/Meta/Tactic/Cases.c        |     4 +-
 stage0/stdlib/Lean/Meta/Tactic/Induction.c    |    10 +-
 stage0/stdlib/Lean/Meta/Tactic/Subst.c        |     4 +-
 stage0/stdlib/Lean/Meta/WHNF.c                |    26 +-
 stage0/stdlib/Lean/Parser/Basic.c             | 16312 +++----
 stage0/stdlib/Lean/Parser/Extension.c         |    34 +-
 stage0/stdlib/Lean/Parser/Module.c            |    13 +-
 stage0/stdlib/Lean/Parser/Term.c              |    10 +-
 stage0/stdlib/Lean/ParserCompiler/Attribute.c |     4 +-
 stage0/stdlib/Lean/ProjFns.c                  |    12 +-
 stage0/stdlib/Lean/ReducibilityAttrs.c        |    26 +-
 stage0/stdlib/Lean/ResolveName.c              |    84 +-
 stage0/stdlib/Lean/Server.c                   |  4267 +-
 stage0/stdlib/Lean/Syntax.c                   |     4 +-
 stage0/stdlib/Lean/Util/FindExpr.c            |  1926 +-
 stage0/stdlib/Lean/Util/FindMVar.c            |   577 +-
 stage0/stdlib/Lean/Util/Path.c                |   911 +-
 stage0/stdlib/Lean/Util/RecDepth.c            |    36 +-
 stage0/stdlib/Lean/Util/Recognizers.c         |   653 +-
 stage0/stdlib/Lean/Util/SCC.c                 |   867 +-
 stage0/stdlib/Lean/Util/Sorry.c               |  3486 +-
 stage0/stdlib/Std/Data/BinomialHeap.c         |  1336 +-
 stage0/stdlib/Std/Data/DList.c                |   100 +-
 stage0/stdlib/Std/Data/Queue.c                |   214 +-
 stage0/stdlib/Std/Data/RBMap.c                | 37619 ++++++++--------
 stage0/stdlib/Std/Data/RBTree.c               |   178 +-
 129 files changed, 73508 insertions(+), 69467 deletions(-)

diff --git a/stage0/src/Lean/Data/Json.lean b/stage0/src/Lean/Data/Json.lean
index f77def6b24..ab489f29c0 100644
--- a/stage0/src/Lean/Data/Json.lean
+++ b/stage0/src/Lean/Data/Json.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Gabriel Ebner. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
diff --git a/stage0/src/Lean/Data/KVMap.lean b/stage0/src/Lean/Data/KVMap.lean
index 5e37d469f2..2b61fc891d 100644
--- a/stage0/src/Lean/Data/KVMap.lean
+++ b/stage0/src/Lean/Data/KVMap.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -151,30 +152,29 @@ subset m₁ m₂ && subset m₂ m₁
 
 instance : HasBeq KVMap := ⟨eqv⟩
 
-class isKVMapVal (α : Type) :=
+class KVMapVal (α : Type) :=
 (defVal : α)
 (set    : KVMap → Name → α → KVMap)
 (get    : KVMap → Name → α → α)
 
-export isKVMapVal (set)
+export KVMapVal (set)
 
-@[inline] def get {α : Type} [isKVMapVal α] (m : KVMap) (k : Name) (defVal := isKVMapVal.defVal) : α :=
-isKVMapVal.get m k defVal
+@[inline] def get {α : Type} [s : KVMapVal α] (m : KVMap) (k : Name) (defVal := s.defVal) : α :=
+KVMapVal.get m k defVal
 
-instance boolVal : isKVMapVal Bool :=
+instance : KVMapVal Bool :=
 { defVal := false, set := setBool, get := fun k n v => getBool k n v }
 
-instance natVal : isKVMapVal Nat :=
+instance : KVMapVal Nat :=
 { defVal := 0, set := setNat, get := fun k n v => getNat k n v }
 
-instance intVal : isKVMapVal Int :=
+instance : KVMapVal Int :=
 { defVal := 0, set := setInt, get := fun k n v => getInt k n v }
 
-instance nameVal : isKVMapVal Name :=
+instance : KVMapVal Name :=
 { defVal := Name.anonymous, set := setName, get := fun k n v => getName k n v }
 
-instance stringVal : isKVMapVal String :=
+instance : KVMapVal String :=
 { defVal := "", set := setString, get := fun k n v => getString k n v }
 
-end KVMap
-end Lean
+end Lean.KVMap
diff --git a/stage0/src/Lean/Data/LBool.lean b/stage0/src/Lean/Data/LBool.lean
index 966e9deda7..a5e6b2c935 100644
--- a/stage0/src/Lean/Data/LBool.lean
+++ b/stage0/src/Lean/Data/LBool.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -48,4 +49,5 @@ def Bool.toLBool : Bool → Lean.LBool
 | false => Lean.LBool.false
 
 @[inline] def toLBoolM {m : Type → Type} [Monad m] (x : m Bool) : m Lean.LBool := do
-b ← x; pure b.toLBool
+let b ← x
+pure b.toLBool
diff --git a/stage0/src/Lean/Data/LOption.lean b/stage0/src/Lean/Data/LOption.lean
index c7efffad0e..148f7d5c81 100644
--- a/stage0/src/Lean/Data/LOption.lean
+++ b/stage0/src/Lean/Data/LOption.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -8,9 +9,9 @@ universes u
 namespace Lean
 
 inductive LOption (α : Type u)
-| none  : LOption
-| some  : α → LOption
-| undef : LOption
+| none  : LOption α
+| some  : α → LOption α
+| undef : LOption α
 
 namespace LOption
 variables {α : Type u}
@@ -36,4 +37,5 @@ def Option.toLOption {α : Type u} : Option α → Lean.LOption α
 | some a => Lean.LOption.some a
 
 @[inline] def toLOptionM {α} {m : Type → Type} [Monad m] (x : m (Option α)) : m (Lean.LOption α) := do
-b ← x; pure b.toLOption
+let b ← x
+pure b.toLOption
diff --git a/stage0/src/Lean/Data/Lsp.lean b/stage0/src/Lean/Data/Lsp.lean
index b33f8bfce3..f1fe849555 100644
--- a/stage0/src/Lean/Data/Lsp.lean
+++ b/stage0/src/Lean/Data/Lsp.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2020 Marc Huisinga. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
diff --git a/stage0/src/Lean/Data/Name.lean b/stage0/src/Lean/Data/Name.lean
index eb6ea552d8..3cc8989729 100644
--- a/stage0/src/Lean/Data/Name.lean
+++ b/stage0/src/Lean/Data/Name.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -8,8 +9,8 @@ import Std.Data.RBMap
 import Std.Data.RBTree
 namespace Lean
 
-instance stringToName : HasCoe String Name :=
-⟨mkNameSimple⟩
+instance : HasCoe String Name := ⟨mkNameSimple⟩ -- TODO delete
+instance : Coe String Name := ⟨mkNameSimple⟩
 
 namespace Name
 
@@ -178,8 +179,8 @@ namespace NameHashSet
 @[inline] def empty : NameHashSet := Std.HashSet.empty
 instance : HasEmptyc NameHashSet := ⟨empty⟩
 instance : Inhabited NameHashSet := ⟨{}⟩
-def insert (s : NameHashSet) (n : Name) := s.insert n
-def contains (s : NameHashSet) (n : Name) : Bool := s.contains n
+def insert (s : NameHashSet) (n : Name) := Std.HashSet.insert s n
+def contains (s : NameHashSet) (n : Name) : Bool := Std.HashSet.contains s n
 end NameHashSet
 
 end Lean
diff --git a/stage0/src/Lean/Data/Occurrences.lean b/stage0/src/Lean/Data/Occurrences.lean
index 91e5680500..b7611382aa 100644
--- a/stage0/src/Lean/Data/Occurrences.lean
+++ b/stage0/src/Lean/Data/Occurrences.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
diff --git a/stage0/src/Lean/Data/OpenDecl.lean b/stage0/src/Lean/Data/OpenDecl.lean
index 30e2f79c24..e33f8f5cef 100644
--- a/stage0/src/Lean/Data/OpenDecl.lean
+++ b/stage0/src/Lean/Data/OpenDecl.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
diff --git a/stage0/src/Lean/Data/Options.lean b/stage0/src/Lean/Data/Options.lean
index 7a86333e94..40f4f10e5a 100644
--- a/stage0/src/Lean/Data/Options.lean
+++ b/stage0/src/Lean/Data/Options.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -33,61 +34,59 @@ private constant optionDeclsRef : IO.Ref OptionDecls := arbitrary _
 
 @[export lean_register_option]
 def registerOption (name : Name) (decl : OptionDecl) : IO Unit := do
-decls ← optionDeclsRef.get;
-when (decls.contains name) $
-  throw $ IO.userError ("invalid option declaration '" ++ toString name ++ "', option already exists");
+let decls ← optionDeclsRef.get
+if decls.contains name then
+  throw $ IO.userError s!"invalid option declaration '{name}', option already exists"
 optionDeclsRef.set $ decls.insert name decl
 
 def getOptionDecls : IO OptionDecls := optionDeclsRef.get
 
 @[export lean_get_option_decls_array]
 def getOptionDeclsArray : IO (Array (Name × OptionDecl)) := do
-decls ← getOptionDecls;
+let decls ← getOptionDecls
 pure $ decls.fold
  (fun (r : Array (Name × OptionDecl)) k v => r.push (k, v))
  #[]
 
 def getOptionDecl (name : Name) : IO OptionDecl := do
-decls ← getOptionDecls;
-(some decl) ← pure (decls.find? name) | throw $ IO.userError ("unknown option '" ++ toString name ++ "'");
+let decls ← getOptionDecls
+let (some decl) ← pure (decls.find? name) | throw $ IO.userError s!"unknown option '{name}'"
 pure decl
 
 def getOptionDefaulValue (name : Name) : IO DataValue := do
-decl ← getOptionDecl name;
+let decl ← getOptionDecl name
 pure decl.defValue
 
 def getOptionDescr (name : Name) : IO String := do
-decl ← getOptionDecl name;
+let decl ← getOptionDecl name
 pure decl.descr
 
 def setOptionFromString (opts : Options) (entry : String) : IO Options := do
-let ps := (entry.splitOn "=").map String.trim;
-[key, val] ← pure ps | throw $ IO.userError "invalid configuration option entry, it must be of the form '<key> = <value>'";
-defValue ← getOptionDefaulValue key.toName;
+let ps := (entry.splitOn "=").map String.trim
+let [key, val] ← pure ps | throw $ IO.userError "invalid configuration option entry, it must be of the form '<key> = <value>'"
+let key := mkNameSimple key
+let defValue ← getOptionDefaulValue key
 match defValue with
 | DataValue.ofString v => pure $ opts.setString key val
 | DataValue.ofBool v   =>
-  if key == "true" then pure $ opts.setBool key true
-  else if key == "false" then pure $ opts.setBool key false
-  else throw $ IO.userError ("invalid Bool option value '" ++ val ++ "'")
+  if key == `true then pure $ opts.setBool key true
+  else if key == `false then pure $ opts.setBool key false
+  else throw $ IO.userError s!"invalid Bool option value '{val}'"
 | DataValue.ofName v   => pure $ opts.setName key val.toName
 | DataValue.ofNat v    =>
   match val.toNat? with
-  | none   => throw (IO.userError ("invalid Nat option value '" ++ val ++ "'"))
+  | none   => throw (IO.userError s!"invalid Nat option value '{val}'")
   | some v => pure $ opts.setNat key v
 | DataValue.ofInt v    =>
   match val.toInt? with
-  | none   => throw (IO.userError ("invalid Int option value '" ++ val ++ "'"))
+  | none   => throw (IO.userError s!"invalid Int option value '{val}'")
   | some v => pure $ opts.setInt key v
 
-@[builtinInit] def verboseOption : IO Unit :=
-registerOption `verbose { defValue := true, group := "", descr := "disable/enable verbose messages" }
+builtin_initialize registerOption `verbose { defValue := true, group := "", descr := "disable/enable verbose messages" }
 
-@[builtinInit] def timeoutOption : IO Unit :=
-registerOption `timeout { defValue := DataValue.ofNat 0, group := "", descr := "the (deterministic) timeout is measured as the maximum of memory allocations (in thousands) per task, the default is unbounded" }
+builtin_initialize registerOption `timeout { defValue := DataValue.ofNat 0, group := "", descr := "the (deterministic) timeout is measured as the maximum of memory allocations (in thousands) per task, the default is unbounded" }
 
-@[builtinInit] def maxMemoryOption : IO Unit :=
-registerOption `maxMemory { defValue := DataValue.ofNat 2048, group := "", descr := "maximum amount of memory available for Lean in megabytes" }
+builtin_initialize registerOption `maxMemory { defValue := DataValue.ofNat 2048, group := "", descr := "maximum amount of memory available for Lean in megabytes" }
 
 class MonadOptions (m : Type → Type) :=
 (getOptions : m Options)
@@ -102,11 +101,11 @@ section Methods
 variables {m : Type → Type} [Monad m] [MonadOptions m]
 
 def getBoolOption (k : Name) (defValue := false) : m Bool := do
-opts ← getOptions;
+let opts ← getOptions
 pure $ opts.getBool k defValue
 
 def getNatOption (k : Name) (defValue := 0) : m Nat := do
-opts ← getOptions;
+let opts ← getOptions
 pure $ opts.getNat k defValue
 
 end Methods
diff --git a/stage0/src/Lean/Data/Position.lean b/stage0/src/Lean/Data/Position.lean
index bf46839a8b..8166eac364 100644
--- a/stage0/src/Lean/Data/Position.lean
+++ b/stage0/src/Lean/Data/Position.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -15,9 +16,12 @@ namespace Position
 instance : DecidableEq Position :=
 fun ⟨l₁, c₁⟩ ⟨l₂, c₂⟩ =>
   if h₁ : l₁ = l₂ then
-  if h₂ : c₁ = c₂ then isTrue (Eq.recOn h₁ (Eq.recOn h₂ rfl))
-  else isFalse (fun contra => Position.noConfusion contra (fun e₁ e₂ => absurd e₂ h₂))
-  else isFalse (fun contra => Position.noConfusion contra (fun e₁ e₂ => absurd e₁ h₁))
+  if h₂ : c₁ = c₂ then
+    isTrue $ by subst h₁; subst h₂; exact rfl
+  else
+    isFalse fun contra => Position.noConfusion contra (fun e₁ e₂ => absurd e₂ h₂)
+  else
+    isFalse fun contra => Position.noConfusion contra (fun e₁ e₂ => absurd e₁ h₁)
 
 protected def lt : Position → Position → Bool
 | ⟨l₁, c₁⟩, ⟨l₂, c₂⟩ => (l₁, c₁) < (l₂, c₂)
@@ -41,39 +45,33 @@ namespace FileMap
 instance : Inhabited FileMap :=
 ⟨{ source := "", positions := #[], lines := #[] }⟩
 
-private partial def ofStringAux (s : String) : String.Pos → Nat → Array String.Pos → Array Nat → FileMap
-| i, line, ps, lines =>
+partial def ofString (s : String) : FileMap :=
+let rec loop (i : String.Pos) (line : Nat) (ps : Array String.Pos) (lines : Array Nat) : FileMap :=
   if s.atEnd i then { source := s, positions := ps.push i, lines := lines.push line }
   else
     let c := s.get i;
     let i := s.next i;
-    if c == '\n' then ofStringAux i (line+1) (ps.push i) (lines.push (line+1))
-    else ofStringAux i line ps lines
+    if c == '\n' then loop i (line+1) (ps.push i) (lines.push (line+1))
+    else loop i line ps lines
+loop 0 1 (#[0]) (#[1])
 
-def ofString (s : String) : FileMap :=
-ofStringAux s 0 1 (#[0]) (#[1])
-
-private partial def toColumnAux (str : String) (pos : String.Pos) : String.Pos → Nat → Nat
-| i, c =>
-  if i == pos || str.atEnd i then c
-  else toColumnAux (str.next i) (c+1)
-
-/- Remark: `pos` is in `[ps.get b, ps.get e]` and `b < e` -/
-private partial def toPositionAux (str : String) (ps : Array Nat) (lines : Array Nat) (pos : String.Pos) : Nat → Nat → Position
-| b, e =>
-  let posB := ps.get! b;
-  if e == b + 1 then { line := lines.get! b, column := toColumnAux str pos posB 0 }
-  else
-    let m := (b + e) / 2;
-    let posM := ps.get! m;
-    if pos == posM then { line := lines.get! m, column := 0 }
-    else if pos > posM then toPositionAux m e
-    else toPositionAux b m
-
-def toPosition : FileMap → String.Pos → Position
-| { source := str, positions := ps, lines := lines }, pos =>
+partial def toPosition (fmap : FileMap) (pos : String.Pos) : Position :=
+match fmap with
+| { source := str, positions := ps, lines := lines } =>
   if ps.size >= 2 && pos <= ps.back then
-    toPositionAux str ps lines pos 0 (ps.size-1)
+    let rec toColumn (i : String.Pos) (c : Nat) : Nat :=
+      if i == pos || str.atEnd i then c
+      else toColumn (str.next i) (c+1)
+    let rec loop (b e : Nat) :=
+      let posB := ps[b]
+      if e == b + 1 then { line := lines.get! b, column := toColumn posB 0 }
+      else
+        let m := (b + e) / 2;
+        let posM := ps.get! m;
+        if pos == posM then { line := lines.get! m, column := 0 }
+        else if pos > posM then loop m e
+        else loop b m
+    loop 0 (ps.size -1)
   else
     -- Some systems like the delaborator use synthetic positions without an input file,
     -- which would violate `toPositionAux`'s invariant
diff --git a/stage0/src/Lean/Data/SMap.lean b/stage0/src/Lean/Data/SMap.lean
index 5bf1f18b35..c0aa7acb2e 100644
--- a/stage0/src/Lean/Data/SMap.lean
+++ b/stage0/src/Lean/Data/SMap.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
diff --git a/stage0/src/Lean/Data/Trie.lean b/stage0/src/Lean/Data/Trie.lean
index 0d89ac5881..e8092d418c 100644
--- a/stage0/src/Lean/Data/Trie.lean
+++ b/stage0/src/Lean/Data/Trie.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -13,7 +14,7 @@ namespace Parser
 open Std (RBNode RBNode.leaf RBNode.singleton RBNode.find RBNode.insert)
 
 inductive Trie (α : Type)
-| Node : Option α → RBNode Char (fun _ => Trie) → Trie
+| Node : Option α → RBNode Char (fun _ => Trie α) → Trie α
 
 namespace Trie
 variables {α : Type}
@@ -27,62 +28,58 @@ instance : HasEmptyc (Trie α) :=
 instance : Inhabited (Trie α) :=
 ⟨Node none RBNode.leaf⟩
 
-private partial def insertEmptyAux (s : String) (val : α) : String.Pos → Trie α
-| i => match s.atEnd i with
+partial def insert (t : Trie α) (s : String) (val : α) : Trie α :=
+let rec insertEmpty (i : String.Pos) : Trie α :=
+  match s.atEnd i with
   | true => Trie.Node (some val) RBNode.leaf
   | false =>
-    let c := s.get i;
-    let t := insertEmptyAux (s.next i);
+    let c := s.get i
+    let t := insertEmpty (s.next i)
     Trie.Node none (RBNode.singleton c t)
+let rec loop
+  | Trie.Node v m, i =>
+    match s.atEnd i with
+    | true  => Trie.Node (some val) m -- overrides old value
+    | false =>
+      let c := s.get i
+      let i := s.next i
+      let t := match RBNode.find Char.lt m c with
+        | none   => insertEmpty i
+        | some t => loop t i
+      Trie.Node v (RBNode.insert Char.lt m c t)
+loop t 0
 
-private partial def insertAux (s : String) (val : α) : Trie α → String.Pos → Trie α
-| Trie.Node v m, i =>
-  match s.atEnd i with
-  | true  => Trie.Node (some val) m -- overrides old value
-  | false =>
-    let c := s.get i;
-    let i := s.next i;
-    let t := match RBNode.find Char.lt m c with
-      | none   => insertEmptyAux s val i
-      | some t => insertAux t i;
-    Trie.Node v (RBNode.insert Char.lt m c t)
-
-def insert (t : Trie α) (s : String) (val : α) : Trie α :=
-insertAux s val t 0
-
-private partial def findAux? (s : String) : Trie α → String.Pos → Option α
-| Trie.Node val m, i =>
-  match s.atEnd i with
-  | true  => val
-  | false =>
-    let c := s.get i;
-    let i := s.next i;
-    match RBNode.find Char.lt m c with
-    | none   => none
-    | some t => findAux? t i
-
-def find? (t : Trie α) (s : String) : Option α :=
-findAux? s t 0
+partial def find? (t : Trie α) (s : String) : Option α :=
+let rec loop
+  | Trie.Node val m, i =>
+    match s.atEnd i with
+    | true  => val
+    | false =>
+      let c := s.get i
+      let i := s.next i
+      match RBNode.find Char.lt m c with
+      | none   => none
+      | some t => loop t i
+loop t 0
 
 private def updtAcc (v : Option α) (i : String.Pos) (acc : String.Pos × Option α) : String.Pos × Option α :=
 match v, acc with
 | some v, (j, w) => (i, some v)  -- we pattern match on `acc` to enable memory reuse
 | none,   acc    => acc
 
-private partial def matchPrefixAux (s : String) : Trie α → String.Pos → (String.Pos × Option α) → String.Pos × Option α
-| Trie.Node v m, i, acc =>
-  match s.atEnd i with
-  | true  => updtAcc v i acc
-  | false =>
-    let acc := updtAcc v i acc;
-    let c   := s.get i;
-    let i   := s.next i;
-    match RBNode.find Char.lt m c with
-    | some t => matchPrefixAux t i acc
-    | none   => acc
-
-def matchPrefix (s : String) (t : Trie α) (i : String.Pos) : String.Pos × Option α :=
-matchPrefixAux s t i (i, none)
+partial def matchPrefix (s : String) (t : Trie α) (i : String.Pos) : String.Pos × Option α :=
+let rec loop
+  | Trie.Node v m, i, acc =>
+    match s.atEnd i with
+    | true  => updtAcc v i acc
+    | false =>
+      let acc := updtAcc v i acc
+      let c   := s.get i
+      let i   := s.next i
+      match RBNode.find Char.lt m c with
+      | some t => loop t i acc
+      | none   => acc
+loop t i (i, none)
 
 private partial def toStringAux {α : Type} : Trie α → List Format
 | Trie.Node val map => map.fold (fun Fs c t =>
diff --git a/stage0/src/Lean/Message.lean b/stage0/src/Lean/Message.lean
index df0d758abe..4d72aedbeb 100644
--- a/stage0/src/Lean/Message.lean
+++ b/stage0/src/Lean/Message.lean
@@ -14,6 +14,9 @@ import Lean.Util.PPExt
 import Lean.Util.PPGoal
 
 namespace Lean
+namespace MonadOptions end MonadOptions -- hack for old frontend
+export MonadOptions (getOptions) -- hack for old frontend
+
 def mkErrorStringWithPos (fileName : String) (line col : Nat) (msg : String) : String :=
 fileName ++ ":" ++ toString line ++ ":" ++ toString col ++ ": " ++ toString msg
 
diff --git a/stage0/src/Lean/Util/FindExpr.lean b/stage0/src/Lean/Util/FindExpr.lean
index a07c7e74ad..c42b607fe5 100644
--- a/stage0/src/Lean/Util/FindExpr.lean
+++ b/stage0/src/Lean/Util/FindExpr.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -15,51 +16,55 @@ abbrev cacheSize : USize := 8192
 structure State :=
 (keys : Array Expr) -- Remark: our "unsafe" implementation relies on the fact that `()` is not a valid Expr
 
-abbrev FindM := StateM State
+abbrev FindM := StateT State Id
 
-@[inline] unsafe def visited (e : Expr) (size : USize) : FindM Bool := do
-s ← get;
-let h := ptrAddrUnsafe e;
-let i := h % size;
-let k := s.keys.uget i lcProof;
+unsafe def visited (e : Expr) (size : USize) : FindM Bool := do
+let s ← get
+let h := ptrAddrUnsafe e
+let i := h % size
+let k := s.keys.uget i lcProof
 if ptrAddrUnsafe k == h then pure true
 else do
-  modify $ fun s => { keys := s.keys.uset i e lcProof };
+  modify $ fun s => { keys := s.keys.uset i e lcProof }
   pure false
 
-@[specialize] unsafe partial def findM? (p : Expr → Bool) (size : USize) : Expr → OptionT FindM Expr
-| e => condM (liftM $ visited e size) failure $
-  if p e then pure e
+@[specialize] unsafe def findM? (p : Expr → Bool) (size : USize) (e : Expr) : OptionT FindM Expr :=
+let rec visit (e : Expr) := do
+  if (← visited e size)  then
+    failure
+  else if p e then
+    pure e
   else match e with
-    | Expr.forallE _ d b _   => findM? d <|> findM? b
-    | Expr.lam _ d b _       => findM? d <|> findM? b
-    | Expr.mdata _ b _       => findM? b
-    | Expr.letE _ t v b _    => findM? t <|> findM? v <|> findM? b
-    | Expr.app f a _         => findM? f <|> findM? a
-    | Expr.proj _ _ b _      => findM? b
+    | Expr.forallE _ d b _   => visit d <|> visit b
+    | Expr.lam _ d b _       => visit d <|> visit b
+    | Expr.mdata _ b _       => visit b
+    | Expr.letE _ t v b _    => visit t <|> visit v <|> visit b
+    | Expr.app f a _         => visit f <|> visit a
+    | Expr.proj _ _ b _      => visit b
     | e                      => failure
+visit e
+
 
 unsafe def initCache : State :=
 { keys    := mkArray cacheSize.toNat (cast lcProof ()) }
 
 @[inline] unsafe def findUnsafe? (p : Expr → Bool) (e : Expr) : Option Expr :=
-(findM? p cacheSize e).run' initCache
+Id.run $ (findM? p cacheSize e).run' initCache
 
 end FindImpl
 
 @[implementedBy FindImpl.findUnsafe?]
-partial def find? (p : Expr → Bool) : Expr → Option Expr
-| e =>
-  /- This is a reference implementation for the unsafe one above -/
-  if p e then some e
-  else match e with
-    | Expr.forallE _ d b _   => find? d <|> find? b
-    | Expr.lam _ d b _       => find? d <|> find? b
-    | Expr.mdata _ b _       => find? b
-    | Expr.letE _ t v b _    => find? t <|> find? v <|> find? b
-    | Expr.app f a _         => find? f <|> find? a
-    | Expr.proj _ _ b _      => find? b
-    | e                      => none
+partial def find? (p : Expr → Bool) (e : Expr) : Option Expr :=
+/- This is a reference implementation for the unsafe one above -/
+if p e then some e
+else match e with
+  | Expr.forallE _ d b _   => find? p d <|> find? p b
+  | Expr.lam _ d b _       => find? p d <|> find? p b
+  | Expr.mdata _ b _       => find? p b
+  | Expr.letE _ t v b _    => find? p t <|> find? p v <|> find? p b
+  | Expr.app f a _         => find? p f <|> find? p a
+  | Expr.proj _ _ b _      => find? p b
+  | e                      => none
 
 /-- Return true if `e` occurs in `t` -/
 def occurs (e : Expr) (t : Expr) : Bool :=
diff --git a/stage0/src/Lean/Util/FindMVar.lean b/stage0/src/Lean/Util/FindMVar.lean
index 8f3cc93e7f..dcb417966b 100644
--- a/stage0/src/Lean/Util/FindMVar.lean
+++ b/stage0/src/Lean/Util/FindMVar.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -11,19 +12,23 @@ namespace FindMVar
 
 abbrev Visitor := Option MVarId → Option MVarId
 
-@[inline] def visit (f : Expr → Visitor) (e : Expr) : Visitor :=
-fun s => if s.isSome || !e.hasMVar then s else f e s
+mutual
+partial def visit (p : MVarId → Bool) (e : Expr) : Visitor :=
+fun s => if s.isSome || !e.hasMVar then s else main p e s
 
-@[specialize] partial def main (p : MVarId → Bool) : Expr → Visitor
-| Expr.proj _ _ e _    => visit main e
-| Expr.forallE _ d b _ => visit main b ∘ visit main d
-| Expr.lam _ d b _     => visit main b ∘ visit main d
-| Expr.letE _ t v b _  => visit main b ∘ visit main v ∘ visit main t
-| Expr.app f a _       => visit main a ∘ visit main f
-| Expr.mdata _ b _     => visit main b
+@[specialize]
+partial def main (p : MVarId → Bool) : Expr → Visitor
+| Expr.proj _ _ e _    => visit p e
+| Expr.forallE _ d b _ => visit p b ∘ visit p d
+| Expr.lam _ d b _     => visit p b ∘ visit p d
+| Expr.letE _ t v b _  => visit p b ∘ visit p v ∘ visit p t
+| Expr.app f a _       => visit p a ∘ visit p f
+| Expr.mdata _ b _     => visit p b
 | Expr.mvar mvarId _   => fun s => if s.isNone && p mvarId then some mvarId else s
 | _                    => id
 
+end
+
 end FindMVar
 
 @[inline] def Expr.findMVar? (e : Expr) (p : MVarId → Bool) : Option MVarId :=
diff --git a/stage0/src/Lean/Util/Path.lean b/stage0/src/Lean/Util/Path.lean
index c83ce9f8d9..ce29340e19 100644
--- a/stage0/src/Lean/Util/Path.lean
+++ b/stage0/src/Lean/Util/Path.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -15,7 +16,7 @@ open System.FilePath (pathSeparator extSeparator)
 private def pathSep : String := toString pathSeparator
 
 def realPathNormalized (fname : String) : IO String := do
-fname ← IO.realPath fname;
+fname ← IO.realPath fname
 pure (System.FilePath.normalizePath fname)
 
 abbrev SearchPath := List String
@@ -33,12 +34,12 @@ pure $ System.FilePath.splitSearchPath path ++ sp
 constant isStage0 (u : Unit) : Bool := arbitrary _
 
 def getBuiltinSearchPath : IO SearchPath := do
-appDir ← IO.appDir;
+let appDir ← IO.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"]
 
 def addSearchPathFromEnv (sp : SearchPath) : IO SearchPath := do
-val ← IO.getEnv "LEAN_PATH";
+let val ← IO.getEnv "LEAN_PATH"
 match val with
 | none     => pure sp
 | some val => parseSearchPath val sp
@@ -48,8 +49,8 @@ def initSearchPath (path : Option String := none) : IO Unit :=
 match path with
 | some path => parseSearchPath path >>= searchPathRef.set
 | none      => do
-  sp ← getBuiltinSearchPath;
-  sp ← addSearchPathFromEnv sp;
+  let sp ← getBuiltinSearchPath
+  let sp ← addSearchPathFromEnv sp
   searchPathRef.set sp
 
 def modPathToFilePath : Name → String
@@ -58,30 +59,30 @@ def modPathToFilePath : Name → String
 | Name.num p _ _              => panic! "ill-formed import"
 
 def findOLean (mod : Name) : IO String := do
-sp ← searchPathRef.get;
-let pkg := mod.getRoot.toString;
-some root ← sp.findM? (fun path => IO.isDir $ path ++ pathSep ++ pkg)
-  | throw $ IO.userError $ "unknown package '" ++ pkg ++ "'";
+let sp ← searchPathRef.get
+let pkg := mod.getRoot.toString
+let some root ← sp.findM? (fun path => IO.isDir $ path ++ pathSep ++ pkg)
+  | throw $ IO.userError $ "unknown package '" ++ pkg ++ "'"
 pure $ root ++ modPathToFilePath mod ++ ".olean"
 
 /-- Infer module name of source file name. -/
 @[export lean_module_name_of_file]
 def moduleNameOfFileName (fname : String) (rootDir : Option String) : IO Name := do
-fname ← realPathNormalized fname;
-rootDir ← match rootDir with
+let fname ← realPathNormalized fname
+let rootDir ← match rootDir with
   | some rootDir => pure rootDir
-  | none         => IO.currentDir;
-rootDir ← realPathNormalized rootDir;
-when (!rootDir.isPrefixOf fname) $
-  throw $ IO.userError $ "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;
-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 mkNameStr Name.anonymous;
+  | none         => IO.currentDir
+let rootDir ← realPathNormalized rootDir
+if !rootDir.isPrefixOf fname 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 mkNameStr Name.anonymous
 pure modName
 
 end Lean
diff --git a/stage0/src/Lean/Util/Profile.lean b/stage0/src/Lean/Util/Profile.lean
index a5e4964cc1..d92d18fe5f 100644
--- a/stage0/src/Lean/Util/Profile.lean
+++ b/stage0/src/Lean/Util/Profile.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Sebastian Ullrich. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
diff --git a/stage0/src/Lean/Util/RecDepth.lean b/stage0/src/Lean/Util/RecDepth.lean
index 669fb61dfd..b1ce31b867 100644
--- a/stage0/src/Lean/Util/RecDepth.lean
+++ b/stage0/src/Lean/Util/RecDepth.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -10,7 +11,6 @@ namespace Lean
 def getMaxRecDepth (opts : Options) : Nat :=
 opts.getNat `maxRecDepth defaultMaxRecDepth
 
-@[builtinInit] def maxRecDepth : IO Unit :=
-registerOption `maxRecDepth { defValue := defaultMaxRecDepth, group := "", descr := "maximum recursion depth for many Lean procedures" }
+builtin_initialize registerOption `maxRecDepth { defValue := defaultMaxRecDepth, group := "", descr := "maximum recursion depth for many Lean procedures" }
 
 end Lean
diff --git a/stage0/src/Lean/Util/Recognizers.lean b/stage0/src/Lean/Util/Recognizers.lean
index 694ca71301..a166fdd7df 100644
--- a/stage0/src/Lean/Util/Recognizers.lean
+++ b/stage0/src/Lean/Util/Recognizers.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -85,15 +86,15 @@ def constructorApp? (env : Environment) (e : Expr) : Option (ConstructorVal × A
 match e with
 | Expr.lit (Literal.natVal n) _ =>
   if n == 0 then do
-    v ← getConstructorVal? env `Nat.zero;
+    let v ← getConstructorVal? env `Nat.zero
     pure (v, #[])
   else do
-    v ← getConstructorVal? env `Nat.succ;
+    let v ← getConstructorVal? env `Nat.succ
     pure (v, #[mkNatLit (n-1)])
 | _ =>
   match e.getAppFn with
   | Expr.const n _ _ => do
-    v ← getConstructorVal? env n;
+    let v ← getConstructorVal? env n
     if v.nparams + v.nfields == e.getAppNumArgs then
       pure (v, e.getAppArgs)
     else
diff --git a/stage0/src/Lean/Util/SCC.lean b/stage0/src/Lean/Util/SCC.lean
index 479f44ffb1..3d6a04c337 100644
--- a/stage0/src/Lean/Util/SCC.lean
+++ b/stage0/src/Lean/Util/SCC.lean
@@ -1,11 +1,11 @@
+#lang lean4
 /-
 Copyright (c) 2020 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
 import Std.Data.HashMap
-namespace Lean
-namespace SCC
+namespace Lean.SCC
 /-
   Very simple implementation of Tarjan's SCC algorithm.
   Performance is not a goal here since we use this module to
@@ -34,7 +34,7 @@ end
 variables {α : Type} [HasBeq α] [Hashable α]
 
 private def getDataOf (a : α) : M α Data := do
-s ← get;
+let s ← get
 match s.data.find? a with
 | some d => pure d
 | none   => pure {}
@@ -74,42 +74,38 @@ private partial def addSCCAux (a : α) : List α → List α → M α Unit
   resetOnStack b;
   let newSCC := b::newSCC;
   if a != b then
-    addSCCAux bs newSCC
+    addSCCAux a bs newSCC
   else
     modify fun s => { s with stack := bs, sccs := newSCC :: s.sccs }
 
 private def addSCC (a : α) : M α Unit := do
-s ← get;
+let s ← get
 addSCCAux a s.stack []
 
-@[specialize] private partial def sccAux (successorsOf : α → List α) : α → M α Unit
-| a => do
-  push a;
-  (successorsOf a).forM fun b => do {
-    bData ← getDataOf b;
-    if bData.index?.isNone then do
-      -- `b` has not been visited yet
-      sccAux b;
-      bData ← getDataOf b;
-      updateLowLinkOf a bData.lowlink?
-    else if bData.onStack then do
-      -- `b` is on the stack. So, it must be in the current SCC
-      -- The edge `(a, b)` is pointing to an SCC already found and must be ignored
-      updateLowLinkOf a bData.index?
-    else
-      pure ()
-  };
-  aData ← getDataOf a;
-  when (aData.lowlink? == aData.index?) $
-    addSCC a
+@[specialize] private partial def sccAux (successorsOf : α → List α) (a : α) : M α Unit := do
+push a
+(successorsOf a).forM fun b => do
+  let bData ← getDataOf b;
+  if bData.index?.isNone then
+    -- `b` has not been visited yet
+    sccAux successorsOf b;
+    let bData ← getDataOf b;
+    updateLowLinkOf a bData.lowlink?
+  else if bData.onStack then do
+    -- `b` is on the stack. So, it must be in the current SCC
+    -- The edge `(a, b)` is pointing to an SCC already found and must be ignored
+    updateLowLinkOf a bData.index?
+  else
+    pure ()
+let aData ← getDataOf a;
+if aData.lowlink? == aData.index? then
+  addSCC a
 
 @[specialize] def scc (vertices : List α) (successorsOf : α → List α) : List (List α) :=
-let main : M α Unit := vertices.forM fun a => do {
-  aData ← getDataOf a;
-  when aData.index?.isNone do sccAux successorsOf a
-};
-let (_, s) := main.run {};
+let main : M α Unit := vertices.forM fun a => do
+  let aData ← getDataOf a
+  if aData.index?.isNone then sccAux successorsOf a
+let (_, s) := main.run {}
 s.sccs.reverse
 
-end SCC
-end Lean
+end Lean.SCC
diff --git a/stage0/src/Lean/Util/Sorry.lean b/stage0/src/Lean/Util/Sorry.lean
index 33b5208637..9e84419af5 100644
--- a/stage0/src/Lean/Util/Sorry.lean
+++ b/stage0/src/Lean/Util/Sorry.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -42,7 +43,7 @@ partial def MessageData.hasSorry : MessageData → Bool
 | MessageData.group msg         => msg.hasSorry
 | MessageData.compose msg₁ msg₂ => msg₁.hasSorry || msg₂.hasSorry
 | MessageData.tagged _ msg      => msg.hasSorry
-| MessageData.node msgs         => msgs.any MessageData.hasSorry
+| MessageData.node msgs         => msgs.any hasSorry
 | _                             => false
 
 partial def MessageData.hasSyntheticSorry : MessageData → Bool
@@ -52,7 +53,7 @@ partial def MessageData.hasSyntheticSorry : MessageData → Bool
 | MessageData.group msg         => msg.hasSyntheticSorry
 | MessageData.compose msg₁ msg₂ => msg₁.hasSyntheticSorry || msg₂.hasSyntheticSorry
 | MessageData.tagged _ msg      => msg.hasSyntheticSorry
-| MessageData.node msgs         => msgs.any MessageData.hasSyntheticSorry
+| MessageData.node msgs         => msgs.any hasSyntheticSorry
 | _                             => false
 
 def Exception.hasSyntheticSorry : Exception → Bool
diff --git a/stage0/src/Std/Data/BinomialHeap.lean b/stage0/src/Std/Data/BinomialHeap.lean
index edd239d008..34d8e699cf 100644
--- a/stage0/src/Std/Data/BinomialHeap.lean
+++ b/stage0/src/Std/Data/BinomialHeap.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -11,8 +12,8 @@ structure HeapNodeAux (α : Type u) (h : Type u) :=
 (val : α) (rank : Nat) (children : List h)
 
 inductive Heap (α : Type u) : Type u
-| empty     : Heap
-| heap  (ns : List (HeapNodeAux α Heap)) : Heap
+| empty     : Heap α
+| heap  (ns : List (HeapNodeAux α (Heap α))) : Heap α
 
 abbrev HeapNode (α) := HeapNodeAux α (Heap α)
 
@@ -41,15 +42,15 @@ else
 | [], h  => h
 | h,  [] => h
 | f@(h₁ :: t₁), s@(h₂ :: t₂) =>
-  if h₁.rank < h₂.rank then h₁ :: mergeNodes t₁ s
-  else if h₂.rank < h₁.rank then h₂ :: mergeNodes t₂ f
+  if h₁.rank < h₂.rank then h₁ :: mergeNodes lt t₁ s
+  else if h₂.rank < h₁.rank then h₂ :: mergeNodes lt t₂ f
   else
     let merged := combine lt h₁ h₂;
     let r      := merged.rank;
     if r != hRank t₁ then
-      if r != hRank t₂ then merged :: mergeNodes t₁ t₂ else mergeNodes (merged :: t₁) t₂
+      if r != hRank t₂ then merged :: mergeNodes lt t₁ t₂ else mergeNodes lt (merged :: t₁) t₂
     else
-      if r != hRank t₂ then mergeNodes t₁ (merged :: t₂) else merged :: mergeNodes t₁ t₂
+      if r != hRank t₂ then mergeNodes lt t₁ (merged :: t₂) else merged :: mergeNodes lt t₁ t₂
 
 @[specialize] def merge (lt : α → α → Bool) : Heap α → Heap α → Heap α
 | Heap.empty,    h           => h
@@ -58,10 +59,9 @@ else
 
 @[specialize] def head? (lt : α → α → Bool) : Heap α → Option α
 | Heap.empty  => none
-| Heap.heap h => h.foldl
-  (fun r n => match r with
-   | none   => n.val
-   | some v => if lt v n.val then v else n.val) none
+| Heap.heap h => h.foldl (init := none) fun r n => match r with
+   | none   => some n.val
+   | some v => if lt v n.val then v else some n.val
 
 /- O(log n) -/
 @[specialize] def head [Inhabited α] (lt : α → α → Bool) : Heap α → α
@@ -71,7 +71,7 @@ else
 
 @[specialize] def findMin (lt : α → α → Bool) : List (HeapNode α) → Nat → HeapNode α × Nat → HeapNode α × Nat
 | [],    _,   r          => r
-| h::hs, idx, (h', idx') => if lt h.val h'.val then findMin hs (idx+1) (h, idx) else findMin hs (idx+1) (h', idx')
+| h::hs, idx, (h', idx') => if lt h.val h'.val then findMin lt hs (idx+1) (h, idx) else findMin lt hs (idx+1) (h', idx')
 
 def tail (lt : α → α → Bool) : Heap α → Heap α
 | Heap.empty        => Heap.empty
@@ -89,13 +89,13 @@ partial def toList (lt : α → α → Bool) : Heap α → List α
 | Heap.empty => []
 | h          => match head? lt h with
   | none   => []
-  | some a => a :: toList (tail lt h)
+  | some a => a :: toList lt (tail lt h)
 
 inductive WellFormed (lt : α → α → Bool) : Heap α → Prop
-| emptyWff               : WellFormed Heap.empty
-| singletonWff (a : α)   : WellFormed (singleton a)
-| mergeWff (h₁ h₂ : Heap α) : WellFormed h₁ → WellFormed h₂ → WellFormed (merge lt h₁ h₂)
-| tailWff (h : Heap α)      : WellFormed h → WellFormed (tail lt h)
+| emptyWff               : WellFormed lt Heap.empty
+| singletonWff (a : α)   : WellFormed lt (singleton a)
+| mergeWff (h₁ h₂ : Heap α) : WellFormed lt h₁ → WellFormed lt h₂ → WellFormed lt (merge lt h₁ h₂)
+| tailWff (h : Heap α)      : WellFormed lt h → WellFormed lt (tail lt h)
 
 end BinomialHeapImp
 
diff --git a/stage0/src/Std/Data/DList.lean b/stage0/src/Std/Data/DList.lean
index 7b6b279e87..31310bfefd 100644
--- a/stage0/src/Std/Data/DList.lean
+++ b/stage0/src/Std/Data/DList.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -20,7 +21,7 @@ variables {α : Type u}
 open List
 
 def ofList (l : List α) : DList α :=
-⟨HasAppend.append l, fun t => (appendNil l).symm ▸ rfl⟩
+⟨HasAppend.append l, fun t => by rw appendNil; exact rfl⟩
 
 def empty : DList α :=
 ⟨id, fun t => rfl⟩
@@ -40,20 +41,26 @@ def cons : α → DList α → DList α
   ⟨fun t => a :: f t,
    fun t =>
     show a :: f t = a :: f [] ++ t from
-    have h₁ : a :: f t = a :: (f nil ++ t) := h t ▸ rfl;
-    have h₂ : a :: (f nil ++ t) = a :: f nil ++ t := (consAppend _ _ _).symm;
+    have h₁ : a :: f t = a :: (f nil ++ t) by rw h t; exact rfl
+    have h₂ : a :: (f nil ++ t) = a :: f nil ++ t := (consAppend _ _ _).symm
     Eq.trans h₁ h₂⟩
 
 def append : DList α → DList α → DList α
 | ⟨f, h₁⟩, ⟨g, h₂⟩ =>
-  ⟨f ∘ g, fun t =>
-    show f (g t) = (f (g [])) ++ t from
-   (h₁ (g [])).symm ▸ (appendAssoc (f []) (g []) t).symm ▸ h₂ t ▸ h₁ (g t) ▸ rfl⟩
+  ⟨f ∘ g, by
+    intro t
+    show f (g t) = (f (g [])) ++ t
+    rw [h₁ (g t), h₂ t, ← appendAssoc (f []) (g []) t, ← h₁ (g [])]
+    exact rfl⟩
 
 def push : DList α → α → DList α
 | ⟨f, h⟩, a =>
   ⟨fun t => f (a :: t),
-   fun t => (h (a::t)).symm ▸ (h [a]).symm ▸ (appendAssoc (f []) [a] t).symm ▸ rfl⟩
+   by
+    intro t
+    show f (a :: t) = f (a :: nil) ++ t
+    rw [h [a], h (a::t), appendAssoc (f []) [a] t]
+    exact rfl⟩
 
 instance : HasAppend (DList α) :=
 ⟨DList.append⟩
diff --git a/stage0/src/Std/Data/Queue.lean b/stage0/src/Std/Data/Queue.lean
index 80b935c397..be7a8aff32 100644
--- a/stage0/src/Std/Data/Queue.lean
+++ b/stage0/src/Std/Data/Queue.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
diff --git a/stage0/src/Std/Data/RBMap.lean b/stage0/src/Std/Data/RBMap.lean
index 192660fec7..5a40bee28b 100644
--- a/stage0/src/Std/Data/RBMap.lean
+++ b/stage0/src/Std/Data/RBMap.lean
@@ -1,3 +1,4 @@
+#lang lean4
 /-
 Copyright (c) 2017 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
@@ -10,8 +11,8 @@ inductive Rbcolor
 | red | black
 
 inductive RBNode (α : Type u) (β : α → Type v)
-| leaf                                                                                : RBNode
-| node  (color : Rbcolor) (lchild : RBNode) (key : α) (val : β key) (rchild : RBNode) : RBNode
+| leaf                                                                                        : RBNode α β
+| node  (color : Rbcolor) (lchild : RBNode α β) (key : α) (val : β key) (rchild : RBNode α β) : RBNode α β
 
 namespace RBNode
 variables {α : Type u} {β : α → Type v} {σ : Type w}
@@ -20,51 +21,51 @@ open Std.Rbcolor Nat
 
 def depth (f : Nat → Nat → Nat) : RBNode α β → Nat
 | leaf           => 0
-| node _ l _ _ r => succ (f (depth l) (depth r))
+| node _ l _ _ r => succ (f (depth f l) (depth f r))
 
 protected def min : RBNode α β → Option (Sigma (fun k => β k))
 | leaf              => none
 | node _ leaf k v _ => some ⟨k, v⟩
-| node _ l k v _    => min l
+| node _ l k v _    => RBNode.min l
 
 protected def max : RBNode α β → Option (Sigma (fun k => β k))
 | leaf              => none
 | node _ _ k v leaf => some ⟨k, v⟩
-| node _ _ k v r    => max r
+| node _ _ k v r    => RBNode.max r
 
 @[specialize] def fold (f : σ → ∀ (k : α), β k → σ) : σ → RBNode α β → σ
 | b, leaf           => b
-| b, node _ l k v r => fold (f (fold b l) k v) r
+| b, node _ l k v r => fold f (f (fold f b l) k v) r
 
-@[specialize] def foldM {m : Type w → Type w'} [Monad m] (f : σ → ∀ (k : α), β k → m σ) : σ → RBNode α β → m σ
-| b, leaf           => pure b
-| b, node _ l k v r => do
-  b ← foldM b l;
-  b ← f b k v;
-  foldM b r
+@[specialize] def foldM {m : Type w → Type w'} [Monad m] (f : σ → ∀ (k : α), β k → m σ) (b : σ) : RBNode α β → m σ
+| leaf           => pure b
+| node _ l k v r => do
+  let b ← foldM f b l
+  let b ← f b k v
+  foldM f b r
 
-@[specialize] def revFold (f : σ → ∀ (k : α), β k → σ) : σ → RBNode α β → σ
-| b, leaf           => b
-| b, node _ l k v r => revFold (f (revFold b r) k v) l
+@[specialize] def revFold (f : σ → ∀ (k : α), β k → σ) (b : σ) : RBNode α β → σ
+| leaf           => b
+| node _ l k v r => revFold f (f (revFold f b r) k v) l
 
 @[specialize] def all (p : ∀ k, β k → Bool) : RBNode α β → Bool
 | leaf           => true
-| node _ l k v r => p k v && all l && all r
+| node _ l k v r => p k v && all p l && all p r
 
 @[specialize] def any (p : ∀ k, β k → Bool) : RBNode α β → Bool
 | leaf             => false
-| node _ l k v r => p k v || any l || any r
+| node _ l k v r => p k v || any p l || any p r
 
 def singleton (k : α) (v : β k) : RBNode α β :=
 node red leaf k v leaf
 
-@[inline] def balance1 : ∀ a, β a → RBNode α β → RBNode α β → RBNode α β
+@[inline] def balance1 : (a : α) → β a → RBNode α β → RBNode α β → RBNode α β
 | kv, vv, t, node _ (node red l kx vx r₁) ky vy r₂   => node red (node black l kx vx r₁) ky vy (node black r₂ kv vv t)
 | kv, vv, t, node _ l₁ ky vy (node red l₂ kx vx r)   => node red (node black l₁ ky vy l₂) kx vx (node black r kv vv t)
 | kv, vv, t, node _ l  ky vy r                       => node black (node red l ky vy r) kv vv t
 | _,  _,  _,                                       _ => leaf -- unreachable
 
-@[inline] def balance2 : RBNode α β → ∀ a, β a → RBNode α β → RBNode α β
+@[inline] def balance2 : RBNode α β → (a : α) → β a → RBNode α β → RBNode α β
 | t, kv, vv, node _ (node red l kx₁ vx₁ r₁) ky vy r₂  => node red (node black t kv vv l) kx₁ vx₁ (node black r₁ ky vy r₂)
 | t, kv, vv, node _ l₁ ky vy (node red l₂ kx₂ vx₂ r₂) => node red (node black t kv vv l₁) ky vy (node black l₂ kx₂ vx₂ r₂)
 | t, kv, vv, node _ l ky vy r                         => node black t kv vv (node red l ky vy r)
@@ -108,12 +109,14 @@ else ins lt t k v
 
 end Insert
 
-def balance₃ : RBNode α β → ∀ k, β k → RBNode α β → RBNode α β
-| node red (node red a kx vx b) ky vy c,   k, v, d => node red (node black a kx vx b) ky vy (node black c k v d)
-| node red a kx vx (node red b ky vy c),   k, v, d => node red (node black a kx vx b) ky vy (node black c k v d)
-| a, k, v, node red b ky vy (node red c kz vz d)   => node red (node black a k v b) ky vy (node black c kz vz d)
-| a, k, v, node red (node red b ky vy c) kz vz d   => node red (node black a k v b) ky vy (node black c kz vz d)
-| l, k, v, r                                       => node black l k v r
+def balance₃ (a : RBNode α β) (k : α) (v : β k) (d : RBNode α β) : RBNode α β :=
+match a with
+| node red (node red a kx vx b) ky vy c => node red (node black a kx vx b) ky vy (node black c k v d)
+| node red a kx vx (node red b ky vy c) => node red (node black a kx vx b) ky vy (node black c k v d)
+| a => match d with
+  | node red b ky vy (node red c kz vz d)   => node red (node black a k v b) ky vy (node black c kz vz d)
+  | node red (node red b ky vy c) kz vz d   => node red (node black a k v b) ky vy (node black c kz vz d)
+  | _                                       => node black a k v d
 
 def setRed : RBNode α β → RBNode α β
 | node _ a k v b => node red a k v b
@@ -156,11 +159,11 @@ variables (lt : α → α → Bool)
 | leaf           => leaf
 | node _ a y v b =>
   if lt x y then
-    if a.isBlack then balLeft (del a) y v b
-    else node red (del a) y v b
+    if a.isBlack then balLeft (del x a) y v b
+    else node red (del x a) y v b
   else if lt y x then
-    if b.isBlack then balRight a y v (del b)
-    else node red a y v (del b)
+    if b.isBlack then balRight a y v (del x b)
+    else node red a y v (del x b)
   else appendTrees a b
 
 @[specialize] def erase (x : α) (t : RBNode α β) : RBNode α β :=
@@ -196,9 +199,9 @@ variable (lt : α → α → Bool)
 end Membership
 
 inductive WellFormed (lt : α → α → Bool) : RBNode α β → Prop
-| leafWff : WellFormed leaf
-| insertWff {n n' : RBNode α β} {k : α} {v : β k} : WellFormed n → n' = insert lt n k v → WellFormed n'
-| eraseWff {n n' : RBNode α β} {k : α} : WellFormed n → n' = erase lt k n → WellFormed n'
+| leafWff : WellFormed lt leaf
+| insertWff {n n' : RBNode α β} {k : α} {v : β k} : WellFormed lt n → n' = insert lt n k v → WellFormed lt n'
+| eraseWff {n n' : RBNode α β} {k : α} : WellFormed lt n → n' = erase lt k n → WellFormed lt n'
 
 end RBNode
 
diff --git a/stage0/stdlib/Lean/Attributes.c b/stage0/stdlib/Lean/Attributes.c
index f3848cab67..92c6e384e8 100644
--- a/stage0/stdlib/Lean/Attributes.c
+++ b/stage0/stdlib/Lean/Attributes.c
@@ -13,17 +13,14 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_List_reverse___rarg(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_getBuiltinAttributeNames___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_EnumAttributes_getValue___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkAttributeExtension___closed__1;
 lean_object* l_Lean_registerEnumAttributes___rarg___lambda__1___boxed(lean_object*, lean_object*);
 size_t l_USize_add(size_t, size_t);
 lean_object* l_Lean_attrParamSyntaxToIdentifier___boxed(lean_object*);
 lean_object* l_Lean_registerTagAttribute___closed__3;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_mkAttributeImplOfBuilder___closed__1;
 uint8_t l_Std_AssocList_contains___at_Lean_registerAttributeImplBuilder___spec__2(lean_object*, lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
@@ -59,11 +56,11 @@ extern lean_object* l_Lean_mkTagDeclarationExtension___closed__1;
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Attributes_2__AttributeExtension_addImported___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___rarg___lambda__2___closed__3;
 lean_object* l_Lean_ParametricAttribute_setParam___rarg___closed__2;
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerInternalExceptionId___closed__2;
 lean_object* l_Lean_attributeExtension___elambda__4___rarg(lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_registerExt___rarg(lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_contains___at_Lean_registerAttributeImplBuilder___spec__1___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_Inhabited(lean_object*);
 lean_object* l_Lean_mkAttributeExtension___closed__2;
 lean_object* l_Lean_mkAttributeImplBuilderTable(lean_object*);
@@ -73,7 +70,6 @@ uint8_t l_Array_anyRangeMAux___main___at_Lean_registerTagAttribute___spec__3(lea
 lean_object* l_Lean_Environment_addAttributeOld___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_environment_find(lean_object*, lean_object*);
 lean_object* l_IO_mkRef___at_Lean_mkAttributeImplBuilderTable___spec__2(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___closed__1;
 lean_object* l_Std_PersistentHashMap_insertAux___main___at_Lean_registerBuiltinAttribute___spec__4(lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerParametricAttribute___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -102,11 +98,13 @@ lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_registerTagAt
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_replace___at_Lean_registerAttributeImplBuilder___spec__7(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1(lean_object*);
 lean_object* l_Lean_attributeMapRef;
 lean_object* l_Lean_attributeImplBuilderTableRef;
 lean_object* l_Lean_AttributeExtensionState_inhabited;
 size_t l_USize_shiftRight(size_t, size_t);
 lean_object* l_Lean_attributeExtension___elambda__2___boxed(lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1(lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_EnumAttributes_getValue___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerParametricAttribute___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_ReaderT_read___at_Lean_attrResolveName___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -117,7 +115,6 @@ lean_object* l_Lean_attributeExtension___elambda__3(lean_object*, lean_object*);
 lean_object* l_Lean_TagAttribute_hasTag___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_TODELETE_popScopeCore(lean_object*);
 extern lean_object* l_Lean_LocalContext_Inhabited___closed__1;
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1(lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___main___at_Lean_getBuiltinAttributeNames___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_attrResolveName___closed__3;
 lean_object* l_Std_PersistentHashMap_findAtAux___main___at_Lean_getBuiltinAttributeImpl___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -131,14 +128,14 @@ lean_object* l_Lean_registerTagAttribute___lambda__4___closed__7;
 lean_object* l_Lean_attrResolveName___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkAttributeImplOfConstant___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkAttributeImplOfConstant___closed__1;
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__3;
 lean_object* l_Lean_attributeExtension___elambda__4(lean_object*, lean_object*);
 lean_object* l_Lean_attrResolveName;
+lean_object* l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_List_forM___main___at_Lean_registerEnumAttributes___spec__10(lean_object*, lean_object*);
 uint8_t l_Lean_AttributeApplicationTime_beq(uint8_t, uint8_t);
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_mkAttributeImplOfBuilder___spec__1(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1(lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerEnumAttributes___spec__4(lean_object*);
 lean_object* l_Lean_mkAttributeExtension___lambda__2___boxed(lean_object*);
 lean_object* l_Lean_registerEnumAttributes___rarg___lambda__2___closed__2;
@@ -158,7 +155,6 @@ lean_object* lean_st_ref_take(lean_object*, lean_object*);
 lean_object* l_EStateM_bind___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerParametricAttribute___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1(lean_object*);
 lean_object* l_Lean_registerParametricAttribute___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Attributes_2__AttributeExtension_addImported(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*);
@@ -196,6 +192,7 @@ lean_object* l_Lean_ofExcept___at_Lean_addAttribute___spec__1(lean_object*, lean
 lean_object* l_Array_qsortAux___main___at_Lean_mkTagDeclarationExtension___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_registerEnumAttributes___spec__7(lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerEnumAttributes___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerParametricAttribute___spec__3(lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
@@ -207,6 +204,7 @@ lean_object* lean_eval_const(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkAttributeExtension___lambda__2(lean_object*);
 lean_object* l_Lean_attributeExtension___closed__4;
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1(lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_ParametricAttribute_getParam___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Environment_evalConstCheck___rarg___closed__1;
 lean_object* l_Lean_TODELETE_pushScopeCore(lean_object*, lean_object*, uint8_t);
@@ -214,7 +212,6 @@ lean_object* l_Lean_registerParametricAttribute___rarg___boxed(lean_object*, lea
 extern lean_object* l_IO_Error_Inhabited___closed__1;
 lean_object* l_Lean_attrParamSyntaxToIdentifier(lean_object*);
 lean_object* l_Lean_registerParametricAttribute___rarg___closed__1;
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__6;
 lean_object* l_Lean_registerParametricAttribute___rarg___closed__2;
 lean_object* l_Lean_mkAttributeExtension___closed__7;
@@ -230,21 +227,21 @@ lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerEnumAttributes___spec__3(lean_object*);
 lean_object* l_Lean_registerParametricAttribute___rarg___lambda__4___boxed(lean_object*);
 lean_object* l_Lean_mkAttributeImplOfEntry(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__3(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1___rarg___boxed(lean_object*, lean_object*);
 size_t l_USize_mul(size_t, size_t);
 lean_object* l_List_redLength___main___rarg(lean_object*);
 lean_object* l_Lean_registerParametricAttribute___rarg___lambda__4___closed__2;
+lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_IO_ofExcept___at_Lean_mkAttributeImplOfBuilder___spec__3(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__3___closed__3;
 lean_object* l_Lean_registerAttributeImplBuilder___closed__2;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1(lean_object*);
 lean_object* l_Lean_registerParametricAttribute___rarg___closed__4;
 extern lean_object* l_Lean_NameSet_empty;
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 lean_object* l_Std_PersistentHashMap_containsAux___main___at_Lean_registerBuiltinAttribute___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_pop_scope(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_registerAttributeImplBuilder___closed__1;
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
 size_t l_USize_land(size_t, size_t);
@@ -252,7 +249,6 @@ extern lean_object* l_Lean_EnvExtensionInterfaceUnsafe_Ext_inhabitedExt___closed
 lean_object* l_Std_HashMapImp_moveEntries___main___at_Lean_registerAttributeImplBuilder___spec__5(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__2;
 lean_object* l_Lean_ParametricAttribute_setParam___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1(lean_object*);
 lean_object* l_Std_PersistentHashMap_contains___at_Lean_registerBuiltinAttribute___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerParametricAttribute___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_attrResolveName___closed__4;
@@ -269,7 +265,6 @@ uint8_t l_Std_PersistentHashMap_containsAux___main___at_Lean_registerBuiltinAttr
 extern lean_object* l_Lean_Syntax_inhabited;
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
 lean_object* l_Lean_EnumAttributes_Inhabited___closed__1;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_isAttribute(lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_mkAttributeExtension___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_getBuiltinAttributeNames___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -287,10 +282,12 @@ uint8_t l_USize_decLe(size_t, size_t);
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__5;
 lean_object* l_Lean_registerAttributeOfDecl___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_attrResolveName___closed__1;
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerEnumAttributes___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_EnumAttributes_setValue___rarg___closed__1;
 lean_object* l_Lean_registerParametricAttribute(lean_object*);
 lean_object* l_Lean_Environment_pushScope___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___rarg___closed__1;
 lean_object* l_Lean_AttributeImpl_inhabited___closed__1;
 lean_object* l_Lean_AttributeApplicationTime_beq___boxed(lean_object*, lean_object*);
@@ -310,10 +307,10 @@ lean_object* l_Lean_registerEnumAttributes___rarg___lambda__2___closed__4;
 lean_object* l_List_map___main___at_Lean_registerEnumAttributes___spec__9___rarg(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_ParametricAttribute_getParam___spec__2(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1(lean_object*);
 lean_object* l_IO_mkRef___at_Lean_mkAttributeMapRef___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__9;
 lean_object* lean_nat_mul(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1(lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_getBuiltinAttributeImpl___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_getParam___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_addAttribute___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -344,8 +341,8 @@ lean_object* l_Lean_PersistentEnvExtension_getState___rarg(lean_object*, lean_ob
 lean_object* l_Array_qsortAux___main___at_Lean_registerEnumAttributes___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_EnumAttributes_getValue___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_registerEnumAttributes___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_mkAttributeImplOfConstantUnsafe___closed__1;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* lean_io_initializing(lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2;
 lean_object* l_Lean_mkAttributeImplOfConstantUnsafe___closed__2;
@@ -354,6 +351,7 @@ uint8_t l_Std_PersistentHashMap_contains___at_Lean_registerBuiltinAttribute___sp
 lean_object* l_Lean_registerParametricAttribute___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_attrResolveName___closed__5;
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__11;
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_EnumAttributes_setValue___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerParametricAttribute___rarg___lambda__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_registerTagAttribute___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -372,16 +370,18 @@ lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*);
 lean_object* l_ReaderT_read___at_Lean_attrResolveName___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_System_FilePath_dirName___closed__1;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__3___closed__4;
 lean_object* lean_add_attribute(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_attributeExtension___elambda__3___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerEnumAttributes___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_usize_to_nat(size_t);
+lean_object* l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_getBuiltinAttributeImpl___closed__1;
 lean_object* l_ReaderT_bind___at_Lean_attrResolveName___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_ReaderT_bind___at_Lean_attrResolveName___spec__2(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1(lean_object*);
 lean_object* l_Lean_registerAttributeImplBuilder(lean_object*, lean_object*, lean_object*);
 lean_object* l_EStateM_pure___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_mkAttributeExtension___closed__5;
@@ -390,11 +390,11 @@ lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_getBuiltinAttribut
 lean_object* l_Lean_attributeExtension___elambda__1(lean_object*);
 lean_object* l_Lean_registerAttributeOfDecl(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__8;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__4___closed__4;
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerEnumAttributes___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_mkAttributeExtension___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1(lean_object*);
 lean_object* l_Lean_registerParametricAttribute___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerTagAttribute___lambda__3___closed__1;
 lean_object* l_Lean_getAttributeNames(lean_object*);
@@ -4914,7 +4914,7 @@ x_10 = l_Lean_addAttribute(x_1, x_2, x_3, x_9, x_5, x_6, x_7, x_8);
 return x_10;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerTagAttribute___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -4931,7 +4931,7 @@ lean_inc(x_4);
 x_5 = lean_ctor_get(x_2, 3);
 lean_inc(x_5);
 lean_dec(x_2);
-x_6 = l_Std_RBNode_fold___main___at_Lean_registerTagAttribute___spec__1(x_1, x_3);
+x_6 = l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(x_1, x_3);
 x_7 = lean_array_push(x_6, x_4);
 x_1 = x_7;
 x_2 = x_5;
@@ -5337,7 +5337,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_registerTagAttribute___spec__1(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -5395,7 +5395,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
 x_4 = l_Nat_repr(x_3);
 x_5 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_5, 0, x_4);
@@ -6018,7 +6018,7 @@ x_5 = lean_box(x_4);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -6032,7 +6032,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -6045,11 +6045,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -6851,7 +6851,7 @@ _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; 
 x_3 = l_Array_empty___closed__1;
-x_4 = l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg(x_3, x_2);
+x_4 = l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg(x_3, x_2);
 x_5 = lean_array_get_size(x_4);
 x_6 = lean_unsigned_to_nat(1u);
 x_7 = lean_nat_sub(x_5, x_6);
@@ -6909,7 +6909,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
 x_4 = l_Nat_repr(x_3);
 x_5 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_5, 0, x_4);
@@ -7288,11 +7288,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_registerParametricAttribute___rarg___box
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_registerParametricAttribute___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_registerParametricAttribute___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -7427,7 +7427,7 @@ x_2 = l_Lean_ParametricAttribute_Inhabited___closed__1;
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -7470,11 +7470,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -7586,7 +7586,7 @@ lean_object* x_6; lean_object* x_7; lean_object* x_8;
 lean_dec(x_1);
 x_6 = lean_ctor_get(x_2, 1);
 x_7 = l_Lean_PersistentEnvExtension_getState___rarg(x_6, x_3);
-x_8 = l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1___rarg(x_7, x_4);
+x_8 = l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1___rarg(x_7, x_4);
 lean_dec(x_4);
 lean_dec(x_7);
 return x_8;
@@ -7657,11 +7657,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_ParametricAttribute_getParam___rarg___bo
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_ParametricAttribute_getParam___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_ParametricAttribute_getParam___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -7687,7 +7687,7 @@ lean_dec(x_2);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -7730,11 +7730,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -7773,7 +7773,7 @@ lean_object* x_6; lean_object* x_7; lean_object* x_8;
 x_6 = lean_ctor_get(x_1, 1);
 lean_inc(x_6);
 x_7 = l_Lean_PersistentEnvExtension_getState___rarg(x_6, x_2);
-x_8 = l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1___rarg(x_7, x_3);
+x_8 = l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1___rarg(x_7, x_3);
 lean_dec(x_7);
 if (lean_obj_tag(x_8) == 0)
 {
@@ -7847,17 +7847,17 @@ x_2 = lean_alloc_closure((void*)(l_Lean_ParametricAttribute_setParam___rarg), 4,
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_ParametricAttribute_setParam___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_ParametricAttribute_setParam___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -7871,7 +7871,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -7884,11 +7884,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -8991,7 +8991,7 @@ _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; 
 x_3 = l_Array_empty___closed__1;
-x_4 = l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg(x_3, x_2);
+x_4 = l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg(x_3, x_2);
 x_5 = lean_array_get_size(x_4);
 x_6 = lean_unsigned_to_nat(1u);
 x_7 = lean_nat_sub(x_5, x_6);
@@ -9049,7 +9049,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
 x_4 = l_Nat_repr(x_3);
 x_5 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_5, 0, x_4);
@@ -9187,11 +9187,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_registerEnumAttributes___rarg___boxed),
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_registerEnumAttributes___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_registerEnumAttributes___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -9327,7 +9327,7 @@ x_2 = l_Lean_EnumAttributes_Inhabited___closed__1;
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -9370,11 +9370,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -9486,7 +9486,7 @@ lean_object* x_6; lean_object* x_7; lean_object* x_8;
 lean_dec(x_1);
 x_6 = lean_ctor_get(x_2, 1);
 x_7 = l_Lean_PersistentEnvExtension_getState___rarg(x_6, x_3);
-x_8 = l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1___rarg(x_7, x_4);
+x_8 = l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg(x_7, x_4);
 lean_dec(x_4);
 lean_dec(x_7);
 return x_8;
@@ -9557,11 +9557,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_EnumAttributes_getValue___rarg___boxed),
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_EnumAttributes_getValue___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_EnumAttributes_getValue___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -9587,7 +9587,7 @@ lean_dec(x_2);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -9630,11 +9630,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -9666,7 +9666,7 @@ x_6 = lean_ctor_get(x_1, 1);
 lean_inc(x_6);
 lean_dec(x_1);
 x_7 = l_Lean_PersistentEnvExtension_getState___rarg(x_6, x_2);
-x_8 = l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1___rarg(x_7, x_3);
+x_8 = l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1___rarg(x_7, x_3);
 lean_dec(x_7);
 if (lean_obj_tag(x_8) == 0)
 {
@@ -9735,11 +9735,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_EnumAttributes_setValue___rarg), 4, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_EnumAttributes_setValue___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_EnumAttributes_setValue___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Class.c b/stage0/stdlib/Lean/Class.c
index 93d07aaa6f..4a2b3c9c98 100644
--- a/stage0/stdlib/Lean/Class.c
+++ b/stage0/stdlib/Lean/Class.c
@@ -1221,54 +1221,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_ClassState_addEntry___spec__2(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_ClassState_addEntry___spec__2(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_ClassState_addEntry___spec__2(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__6(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__6(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__6(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__6(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
@@ -2075,54 +2081,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_ClassState_addEntry___spec__13(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_ClassState_addEntry___spec__13(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_ClassState_addEntry___spec__13(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__17(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__17(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__17(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_ClassState_addEntry___spec__17(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Compiler/ClosedTermCache.c b/stage0/stdlib/Lean/Compiler/ClosedTermCache.c
index 169f7e0686..813de5b10d 100644
--- a/stage0/stdlib/Lean/Compiler/ClosedTermCache.c
+++ b/stage0/stdlib/Lean/Compiler/ClosedTermCache.c
@@ -959,54 +959,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____spec__2(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____spec__2(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____spec__2(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____spec__6(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____spec__6(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____spec__6(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_initFn____x40_Lean_Compiler_ClosedTermCache___hyg_8____spec__6(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Compiler/ExportAttr.c b/stage0/stdlib/Lean/Compiler/ExportAttr.c
index c1b9be85ff..47eb33ed65 100644
--- a/stage0/stdlib/Lean/Compiler/ExportAttr.c
+++ b/stage0/stdlib/Lean/Compiler/ExportAttr.c
@@ -20,11 +20,13 @@ lean_object* l_Lean_isExport___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81__match__1(lean_object*);
 lean_object* lean_nat_div(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_getModuleEntries___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_getParam___at_Lean_getExportNameFor___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____closed__5;
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_ExportAttr_0__Lean_isValidCppName___boxed(lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerInternalExceptionId___closed__2;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_registerExt___rarg(lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
@@ -47,12 +49,10 @@ lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____lambda__1
 lean_object* l_String_anyAux___main___at___private_Lean_Compiler_ExportAttr_0__Lean_isValidCppId___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Environment_8__persistentEnvExtensionsRef;
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81__match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_utf8_next(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_ExportAttr_0__Lean_isValidCppName_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2___boxed(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
 lean_object* l_EStateM_bind___rarg(lean_object*, lean_object*, lean_object*);
@@ -85,12 +85,12 @@ uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__5(lean_object*, lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____closed__2;
 extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__3;
 lean_object* l_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____closed__1;
 lean_object* l_Lean_registerParametricAttribute___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__1___lambda__1(lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_addAttribute___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -414,7 +414,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_initFn____x40_Lean_Compiler_ExportAttr__
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -428,7 +428,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -971,7 +971,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -1274,11 +1274,11 @@ x_7 = l_Lean_registerParametricAttribute___at_Lean_initFn____x40_Lean_Compiler_E
 return x_7;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExportAttr___hyg_81____spec__2(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -1451,7 +1451,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
diff --git a/stage0/stdlib/Lean/Compiler/ExternAttr.c b/stage0/stdlib/Lean/Compiler/ExternAttr.c
index b851f41feb..548e84251a 100644
--- a/stage0/stdlib/Lean/Compiler/ExternAttr.c
+++ b/stage0/stdlib/Lean/Compiler/ExternAttr.c
@@ -16,6 +16,7 @@ extern "C" {
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternEntries_match__5(lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__9(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_push(lean_object*, uint32_t);
+lean_object* l_Std_RBNode_find___at_Lean_getExternAttrData___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isNatLitAux(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternEntries_match__4(lean_object*);
 lean_object* l_Lean_getExternEntryForAux(lean_object*, lean_object*);
@@ -80,7 +81,6 @@ lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_expandExternPatternAux_match__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Environment_8__persistentEnvExtensionsRef;
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData___closed__10;
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(lean_object*, lean_object*);
 uint8_t l_Lean_Environment_isConstructor(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternEntries_match__5___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -151,7 +151,6 @@ lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternEntries_
 lean_object* l_Lean_getConstInfo___at_Lean_getExternConstArity___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 uint8_t l_String_Iterator_hasNext(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_getExternAttrData___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_ofExcept___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_getExternConstArity___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerParametricAttribute___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -169,7 +168,6 @@ extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed_
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData_match__2(lean_object*);
 lean_object* l_Lean_getExternNameFor_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getExternEntryForAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_getExternAttrData___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_addMessageContextPartial___at_Lean_Core_Lean_AddMessageContext___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData_match__4___rarg(lean_object*, lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
@@ -199,6 +197,7 @@ lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData
 lean_object* l_Lean_isExternC_match__1(lean_object*);
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData___closed__2;
 lean_object* l_Lean_getExternConstArity_match__3___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_getExternAttrData___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_getState___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2;
 lean_object* lean_string_length(lean_object*);
@@ -230,10 +229,11 @@ lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternAttrData___closed__6;
 lean_object* l___private_Lean_Compiler_ExternAttr_0__Lean_syntaxToExternEntries___closed__5;
 lean_object* l_List_foldl___main___at_Lean_mkSimpleFnCall___spec__1(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_getParam___at_Lean_getExternAttrData___spec__1(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_NameGenerator_Inhabited___closed__3;
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5___boxed(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_Lean_getExternConstArity(lean_object*, lean_object*, lean_object*, lean_object*);
 static lean_object* _init_l_Lean_ExternAttrData_arity_x3f___default() {
@@ -1316,7 +1316,7 @@ return x_26;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -1330,7 +1330,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -1874,7 +1874,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -2349,11 +2349,11 @@ lean_dec(x_2);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Compiler_ExternAttr___hyg_372____spec__5(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -2434,7 +2434,7 @@ lean_dec(x_2);
 return x_7;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getExternAttrData___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_getExternAttrData___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -2568,7 +2568,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at_Lean_getExternAttrData___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at_Lean_getExternAttrData___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
@@ -2641,11 +2641,11 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getExternAttrData___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_getExternAttrData___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_getExternAttrData___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_getExternAttrData___spec__2(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Compiler/IR/Basic.c b/stage0/stdlib/Lean/Compiler/IR/Basic.c
index 41dc65ed94..59f7572068 100644
--- a/stage0/stdlib/Lean/Compiler/IR/Basic.c
+++ b/stage0/stdlib/Lean/Compiler/IR/Basic.c
@@ -19,7 +19,6 @@ lean_object* l_Lean_IR_Lean_Compiler_IR_Basic___instance__11;
 lean_object* l_Lean_IR_FnBody_body___boxed(lean_object*);
 lean_object* l_Lean_IR_AltCore_mmodifyBody_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_CtorInfo_HasBeq___closed__1;
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Arg_Lean_Compiler_IR_Basic___instance__9___closed__1;
 lean_object* l_Lean_IR_reshapeAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_addParamsRename(lean_object*, lean_object*, lean_object*);
@@ -56,12 +55,12 @@ lean_object* l_Lean_IR_mmodifyJPs___rarg(lean_object*, lean_object*, lean_object
 uint8_t l_Lean_IR_IRType_isIrrelevant(lean_object*);
 lean_object* l_Lean_IR_IRType_isObj_match__1(lean_object*);
 size_t l_Lean_IR_JoinPointId_Lean_Compiler_IR_Basic___instance__8(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Expr_alphaEqv_match__1___rarg___boxed(lean_object**);
 lean_object* l_Lean_IR_VarIdSet_Lean_Compiler_IR_Basic___instance__13;
 lean_object* l_Lean_IR_LocalContext_getJPParams(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Decl_name_match__1(lean_object*);
 lean_object* l_Array_iterateM_u2082Aux___main___at_Lean_IR_addParamsRename___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_IR_CtorInfo_isScalar(lean_object*);
 uint8_t l_Lean_IR_LocalContext_isParam(lean_object*, lean_object*);
 uint8_t l_Lean_IR_FnBody_alphaEqv(lean_object*, lean_object*, lean_object*);
@@ -70,7 +69,6 @@ lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_modifyJPs___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_flattenAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_ir_mk_str_expr(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1___boxed(lean_object*, lean_object*);
 uint8_t l_Array_isEqvAux___main___at_Lean_IR_IRType_beq___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_IR_FnBody_setBody_match__1___rarg(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*);
@@ -81,9 +79,9 @@ lean_object* l_Lean_IR_LocalContext_addParams___boxed(lean_object*, lean_object*
 lean_object* l_Lean_IR_LocalContext_getType_match__1(lean_object*);
 lean_object* l_Lean_IR_IRType_isUnion___boxed(lean_object*);
 lean_object* l_Lean_IR_FnBody_alphaEqv_match__1(lean_object*);
-lean_object* l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2___boxed(lean_object*, lean_object*);
 lean_object* lean_ir_mk_param(lean_object*, uint8_t, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_1__swapAtPanic_x21___at_Lean_IR_reshapeAux___spec__1___closed__1;
+lean_object* l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_IR_IRType_isObj(lean_object*);
 lean_object* l_Lean_IR_Arg_alphaEqv___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -104,12 +102,13 @@ lean_object* l_Lean_IR_AltCore_body(lean_object*);
 lean_object* l_Lean_IR_VarId_alphaEqv_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LitVal_beq_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LocalContext_getType_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
 lean_object* l_Lean_IR_Arg_beq_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* lean_ir_mk_papp_expr(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Arg_Lean_Compiler_IR_Basic___instance__9;
+lean_object* l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(lean_object*, lean_object*);
 uint8_t l_Lean_IR_args_alphaEqv(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Arg_hasAeqv___closed__1;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
@@ -145,6 +144,7 @@ lean_object* l_Lean_IR_AltCore_modifyBody(lean_object*, lean_object*);
 lean_object* l_Lean_IR_IRType_isObj_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LocalContext_isParam_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees___rarg(lean_object*, lean_object*);
 uint8_t l_Lean_IR_FnBody_isTerminal(lean_object*);
 lean_object* l_Lean_IR_Decl_params___boxed(lean_object*);
 uint8_t l_Lean_IR_FnBody_beq(lean_object*, lean_object*);
@@ -183,6 +183,7 @@ lean_object* l_Lean_IR_Arg_hasAeqv;
 lean_object* l_Lean_IR_flattenAux(lean_object*, lean_object*);
 lean_object* l_Lean_IR_VarId_hasAeqv;
 lean_object* lean_ir_mk_app_expr(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Expr_hasAeqv;
 lean_object* l_Lean_IR_JoinPointId_Lean_Compiler_IR_Basic___instance__6(lean_object*);
 lean_object* l_Lean_IR_AltCore_mmodifyBody___rarg___closed__1;
@@ -191,7 +192,6 @@ lean_object* l_Lean_IR_AltCore_setBody_match__1(lean_object*);
 lean_object* l_Lean_IR_Decl_resultType_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_mkIf___closed__4;
 lean_object* l_Std_RBNode_balLeft___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_appendTrees___main___rarg(lean_object*, lean_object*);
 lean_object* lean_ir_mk_proj_expr(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Alt_ctor(lean_object*, lean_object*);
 lean_object* l_Lean_IR_LocalContext_getValue_match__1(lean_object*);
@@ -221,9 +221,7 @@ extern lean_object* l_Bool_HasRepr___closed__1;
 lean_object* l_Lean_IR_FnBody_body_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_IR_LitVal_beq(lean_object*, lean_object*);
 lean_object* l_Lean_IR_AltCore_setBody(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_IR_LocalContext_contains___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_flattenAux_match__1(lean_object*);
 lean_object* l_Lean_IR_Decl_isExtern_match__1(lean_object*);
 lean_object* l_Lean_IR_FnBody_setBody(lean_object*, lean_object*);
@@ -251,7 +249,6 @@ lean_object* l_Lean_IR_mkIf___closed__1;
 lean_object* l_Lean_IR_LocalContext_getJPBody_match__1(lean_object*);
 lean_object* l_Lean_IR_mkIndexSet(lean_object*);
 lean_object* l_Lean_IR_reshape(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_IR_LocalContext_addParams___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Decl_resultType___boxed(lean_object*);
 lean_object* l_Lean_IR_LocalContext_addLocal(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -296,20 +293,23 @@ lean_object* l_Lean_IR_AltCore_modifyBody_match__1(lean_object*);
 lean_object* l_Lean_IR_mkParam___boxed(lean_object*, lean_object*, lean_object*);
 size_t l_Lean_IR_VarId_Lean_Compiler_IR_Basic___instance__4(lean_object*);
 lean_object* l_Lean_IR_FnBody_alphaEqv_match__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_VarId_Lean_Compiler_IR_Basic___instance__2(lean_object*);
 uint8_t l_Lean_KVMap_eqv(lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Array_isEqvAux___main___at_Lean_IR_FnBody_alphaEqv___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_IR_Alt_isDefault(lean_object*);
 lean_object* l_Lean_IR_LocalContext_getType___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_LocalContext_isJP_match__1(lean_object*);
 lean_object* l_Lean_IR_FnBody_body(lean_object*);
 lean_object* lean_ir_mk_decl(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_VarId_Lean_Compiler_IR_Basic___instance__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_reshapeAux_match__2(lean_object*);
 lean_object* l_Array_isEqvAux___main___at_Lean_IR_IRType_beq___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_reshapeAux_match__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_FnBody_isTerminal_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_FnBody_alphaEqv_match__3___rarg___boxed(lean_object**);
 lean_object* l_Lean_IR_Decl_params(lean_object*);
@@ -4794,2380 +4794,2457 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_nat_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_nat_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_nat_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_nat_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_nat_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_nat_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_nat_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_nat_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_nat_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_nat_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_nat_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_nat_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_nat_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_nat_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_nat_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_nat_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -7187,13 +7264,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_IR_mkIndexSet___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_IR_mkIndexSet___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -7209,2380 +7286,2457 @@ x_4 = l_Std_RBNode_insert___at_Lean_IR_mkIndexSet___spec__1(x_2, x_1, x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_nat_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_nat_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_nat_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_nat_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_nat_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_nat_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_nat_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_nat_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_nat_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_nat_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_nat_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_nat_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_nat_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_nat_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_nat_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_nat_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -9602,13 +9756,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_IR_LocalContext_addLocal___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_IR_LocalContext_addLocal___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -9752,7 +9906,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_IR_LocalContext_isJP_match__1___rarg), 3
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -9799,7 +9953,7 @@ uint8_t l_Lean_IR_LocalContext_isJP(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -9829,11 +9983,11 @@ return x_7;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -9901,7 +10055,7 @@ lean_object* l_Lean_IR_LocalContext_getJPBody(lean_object* x_1, lean_object* x_2
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; 
@@ -10022,7 +10176,7 @@ lean_object* l_Lean_IR_LocalContext_getJPParams(lean_object* x_1, lean_object* x
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; 
@@ -10141,7 +10295,7 @@ uint8_t l_Lean_IR_LocalContext_isParam(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -10233,7 +10387,7 @@ uint8_t l_Lean_IR_LocalContext_isLocalVar(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -10278,7 +10432,7 @@ uint8_t l_Lean_IR_LocalContext_contains(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -10305,158 +10459,160 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
 {
-return x_2;
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
 }
 else
 {
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_2);
+if (x_4 == 0)
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = lean_ctor_get(x_2, 1);
-x_6 = lean_ctor_get(x_2, 2);
-x_7 = lean_ctor_get(x_2, 3);
-x_8 = lean_nat_dec_lt(x_1, x_5);
-if (x_8 == 0)
-{
-uint8_t x_9; 
-x_9 = lean_nat_dec_lt(x_5, x_1);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_ctor_get(x_2, 1);
+x_7 = lean_ctor_get(x_2, 2);
+x_8 = lean_ctor_get(x_2, 3);
+x_9 = lean_nat_dec_lt(x_1, x_6);
 if (x_9 == 0)
 {
-lean_object* x_10; 
+uint8_t x_10; 
+x_10 = lean_nat_dec_lt(x_6, x_1);
+if (x_10 == 0)
+{
+lean_object* x_11; 
 lean_free_object(x_2);
+lean_dec(x_7);
 lean_dec(x_6);
-lean_dec(x_5);
-x_10 = l_Std_RBNode_appendTrees___main___rarg(x_4, x_7);
-return x_10;
+x_11 = l_Std_RBNode_appendTrees___rarg(x_5, x_8);
+return x_11;
 }
 else
 {
-uint8_t x_11; 
-x_11 = l_Std_RBNode_isBlack___rarg(x_7);
-if (x_11 == 0)
+uint8_t x_12; 
+x_12 = l_Std_RBNode_isBlack___rarg(x_8);
+if (x_12 == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-x_12 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_7);
-x_13 = 0;
-lean_ctor_set(x_2, 3, x_12);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_13);
+lean_object* x_13; uint8_t x_14; 
+x_13 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_8);
+x_14 = 0;
+lean_ctor_set(x_2, 3, x_13);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_14);
 return x_2;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; 
+lean_object* x_15; lean_object* x_16; 
 lean_free_object(x_2);
-x_14 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_7);
-x_15 = l_Std_RBNode_balRight___rarg(x_4, x_5, x_6, x_14);
-return x_15;
+x_15 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_8);
+x_16 = l_Std_RBNode_balRight___rarg(x_5, x_6, x_7, x_15);
+return x_16;
 }
 }
 }
 else
 {
-uint8_t x_16; 
-x_16 = l_Std_RBNode_isBlack___rarg(x_4);
-if (x_16 == 0)
+uint8_t x_17; 
+x_17 = l_Std_RBNode_isBlack___rarg(x_5);
+if (x_17 == 0)
 {
-lean_object* x_17; uint8_t x_18; 
-x_17 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_4);
-x_18 = 0;
-lean_ctor_set(x_2, 0, x_17);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_18);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_5);
+x_19 = 0;
+lean_ctor_set(x_2, 0, x_18);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_19);
 return x_2;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; 
+lean_object* x_20; lean_object* x_21; 
 lean_free_object(x_2);
-x_19 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_4);
-x_20 = l_Std_RBNode_balLeft___rarg(x_19, x_5, x_6, x_7);
-return x_20;
+x_20 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_5);
+x_21 = l_Std_RBNode_balLeft___rarg(x_20, x_6, x_7, x_8);
+return x_21;
 }
 }
 }
 else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_21 = lean_ctor_get(x_2, 0);
-x_22 = lean_ctor_get(x_2, 1);
-x_23 = lean_ctor_get(x_2, 2);
-x_24 = lean_ctor_get(x_2, 3);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_22 = lean_ctor_get(x_2, 0);
+x_23 = lean_ctor_get(x_2, 1);
+x_24 = lean_ctor_get(x_2, 2);
+x_25 = lean_ctor_get(x_2, 3);
+lean_inc(x_25);
 lean_inc(x_24);
 lean_inc(x_23);
 lean_inc(x_22);
-lean_inc(x_21);
 lean_dec(x_2);
-x_25 = lean_nat_dec_lt(x_1, x_22);
-if (x_25 == 0)
-{
-uint8_t x_26; 
-x_26 = lean_nat_dec_lt(x_22, x_1);
+x_26 = lean_nat_dec_lt(x_1, x_23);
 if (x_26 == 0)
 {
-lean_object* x_27; 
+uint8_t x_27; 
+x_27 = lean_nat_dec_lt(x_23, x_1);
+if (x_27 == 0)
+{
+lean_object* x_28; 
+lean_dec(x_24);
 lean_dec(x_23);
-lean_dec(x_22);
-x_27 = l_Std_RBNode_appendTrees___main___rarg(x_21, x_24);
-return x_27;
+x_28 = l_Std_RBNode_appendTrees___rarg(x_22, x_25);
+return x_28;
 }
 else
 {
-uint8_t x_28; 
-x_28 = l_Std_RBNode_isBlack___rarg(x_24);
-if (x_28 == 0)
+uint8_t x_29; 
+x_29 = l_Std_RBNode_isBlack___rarg(x_25);
+if (x_29 == 0)
 {
-lean_object* x_29; uint8_t x_30; lean_object* x_31; 
-x_29 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_24);
-x_30 = 0;
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_21);
-lean_ctor_set(x_31, 1, x_22);
-lean_ctor_set(x_31, 2, x_23);
-lean_ctor_set(x_31, 3, x_29);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_30);
-return x_31;
+lean_object* x_30; uint8_t x_31; lean_object* x_32; 
+x_30 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_25);
+x_31 = 0;
+x_32 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_32, 0, x_22);
+lean_ctor_set(x_32, 1, x_23);
+lean_ctor_set(x_32, 2, x_24);
+lean_ctor_set(x_32, 3, x_30);
+lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31);
+return x_32;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_24);
-x_33 = l_Std_RBNode_balRight___rarg(x_21, x_22, x_23, x_32);
-return x_33;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_25);
+x_34 = l_Std_RBNode_balRight___rarg(x_22, x_23, x_24, x_33);
+return x_34;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = l_Std_RBNode_isBlack___rarg(x_21);
-if (x_34 == 0)
+uint8_t x_35; 
+x_35 = l_Std_RBNode_isBlack___rarg(x_22);
+if (x_35 == 0)
 {
-lean_object* x_35; uint8_t x_36; lean_object* x_37; 
-x_35 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_21);
-x_36 = 0;
-x_37 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_22);
-lean_ctor_set(x_37, 2, x_23);
-lean_ctor_set(x_37, 3, x_24);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
-return x_37;
+lean_object* x_36; uint8_t x_37; lean_object* x_38; 
+x_36 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_22);
+x_37 = 0;
+x_38 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_23);
+lean_ctor_set(x_38, 2, x_24);
+lean_ctor_set(x_38, 3, x_25);
+lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_37);
+return x_38;
 }
 else
 {
-lean_object* x_38; lean_object* x_39; 
-x_38 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_21);
-x_39 = l_Std_RBNode_balLeft___rarg(x_38, x_22, x_23, x_24);
-return x_39;
+lean_object* x_39; lean_object* x_40; 
+x_39 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_22);
+x_40 = l_Std_RBNode_balLeft___rarg(x_39, x_23, x_24, x_25);
+return x_40;
 }
 }
 }
@@ -10467,7 +10623,7 @@ lean_object* l_Std_RBNode_erase___at_Lean_IR_LocalContext_eraseJoinPointDecl___s
 _start:
 {
 lean_object* x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_2);
 x_4 = l_Std_RBNode_setBlack___rarg(x_3);
 return x_4;
 }
@@ -10480,11 +10636,11 @@ x_3 = l_Std_RBNode_erase___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__1(
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_del___main___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__2(x_1, x_2);
 lean_dec(x_1);
 return x_3;
 }
@@ -10575,7 +10731,7 @@ lean_object* l_Lean_IR_LocalContext_getType(lean_object* x_1, lean_object* x_2)
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; 
@@ -10696,7 +10852,7 @@ lean_object* l_Lean_IR_LocalContext_getValue(lean_object* x_1, lean_object* x_2)
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_LocalContext_isJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; 
@@ -10797,7 +10953,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_IR_VarId_alphaEqv_match__1___rarg), 3, 0
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -10844,7 +11000,7 @@ uint8_t l_Lean_IR_VarId_alphaEqv(lean_object* x_1, lean_object* x_2, lean_object
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1(x_1, x_2);
+x_4 = l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 uint8_t x_5; 
@@ -10863,11 +11019,11 @@ return x_7;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -12184,2380 +12340,2457 @@ x_1 = l_Lean_IR_Expr_hasAeqv___closed__1;
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_nat_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_nat_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_nat_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_nat_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_nat_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_nat_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_nat_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_nat_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_nat_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_nat_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_nat_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_nat_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_nat_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_nat_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_nat_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_nat_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -14577,13 +14810,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_IR_addVarRename___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_IR_addVarRename___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
diff --git a/stage0/stdlib/Lean/Compiler/IR/Borrow.c b/stage0/stdlib/Lean/Compiler/IR/Borrow.c
index 832a30658f..f0f37d913e 100644
--- a/stage0/stdlib/Lean/Compiler/IR/Borrow.c
+++ b/stage0/stdlib/Lean/Compiler/IR/Borrow.c
@@ -15,6 +15,7 @@ extern "C" {
 #endif
 extern lean_object* l_Lean_IR_Lean_Compiler_IR_Basic___instance__11;
 lean_object* l_Std_AssocList_replace___at_Lean_IR_Borrow_OwnedSet_insert___spec__6(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Array_iterateMAux___main___at_Lean_IR_Borrow_updateParamSet___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_IR_Borrow_OwnedSet_beq(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_ownArg_match__1(lean_object*);
@@ -48,6 +49,7 @@ lean_object* l_Lean_IR_Borrow_OwnedSet_Lean_Compiler_IR_Borrow___instance__1___c
 lean_object* l_Lean_IR_Borrow_preserveTailCall_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_InitParamMap_visitDecls(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_OwnedSet_contains___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___at_Lean_IR_Borrow_OwnedSet_insert___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_getParamInfo_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_foldlM___at_Lean_IR_Borrow_OwnedSet_insert___spec__5(lean_object*, lean_object*);
@@ -184,7 +186,6 @@ lean_object* l_Array_forMAux___main___at_Lean_IR_Borrow_ownArgs___spec__1___boxe
 lean_object* l_Lean_IR_inferBorrow(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_isOwned___boxed(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_IR_Borrow_updateParamMap_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_ApplyParamMap_visitDecls_match__1(lean_object*);
 lean_object* l_Lean_IR_Borrow_ApplyParamMap_visitFnBody_match__2___rarg(lean_object*, lean_object*);
@@ -193,7 +194,6 @@ lean_object* l_Lean_IR_Borrow_ownArgsIfParam(lean_object*, lean_object*, lean_ob
 lean_object* l_Lean_IR_Borrow_ownArgsUsingParams(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_ownArgsIfParam___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_IR_Decl_Lean_Compiler_IR_Basic___instance__12;
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_Borrow_updateParamMap___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_InitParamMap_visitFnBody(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Borrow_InitParamMap_initBorrowIfNotExported___boxed(lean_object*, lean_object*);
@@ -2307,7 +2307,7 @@ x_1 = l_Lean_IR_Borrow_ApplyParamMap_visitFnBody___closed__1;
 x_2 = l_Lean_IR_Borrow_ApplyParamMap_visitFnBody___closed__2;
 x_3 = lean_unsigned_to_nat(119u);
 x_4 = lean_unsigned_to_nat(15u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -2591,7 +2591,7 @@ x_1 = l_Lean_IR_Borrow_ApplyParamMap_visitFnBody___closed__1;
 x_2 = l_Array_umapMAux___main___at_Lean_IR_Borrow_ApplyParamMap_visitDecls___spec__1___closed__1;
 x_3 = lean_unsigned_to_nat(135u);
 x_4 = lean_unsigned_to_nat(17u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -3714,7 +3714,7 @@ x_1 = l_Lean_IR_Borrow_ApplyParamMap_visitFnBody___closed__1;
 x_2 = l_Lean_IR_Borrow_getParamInfo___closed__3;
 x_3 = lean_unsigned_to_nat(210u);
 x_4 = lean_unsigned_to_nat(19u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -3727,7 +3727,7 @@ x_1 = l_Lean_IR_Borrow_ApplyParamMap_visitFnBody___closed__1;
 x_2 = l_Lean_IR_Borrow_getParamInfo___closed__3;
 x_3 = lean_unsigned_to_nat(211u);
 x_4 = lean_unsigned_to_nat(9u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -4088,7 +4088,7 @@ x_11 = lean_ctor_get(x_10, 0);
 lean_inc(x_11);
 lean_dec(x_10);
 x_12 = lean_ctor_get(x_1, 2);
-x_13 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_11);
+x_13 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_11);
 if (lean_obj_tag(x_13) == 0)
 {
 lean_object* x_14; lean_object* x_15; 
diff --git a/stage0/stdlib/Lean/Compiler/IR/Checker.c b/stage0/stdlib/Lean/Compiler/IR/Checker.c
index a170ab9277..7e84a4ba75 100644
--- a/stage0/stdlib/Lean/Compiler/IR/Checker.c
+++ b/stage0/stdlib/Lean/Compiler/IR/Checker.c
@@ -67,6 +67,7 @@ uint8_t l_Lean_IR_CtorInfo_isRef(lean_object*);
 lean_object* l_Lean_IR_LocalContext_addJP(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkObjVar___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkObjType(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_Checker_markIndex___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_getDecl___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkPartialApp(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkExpr_match__2(lean_object*);
@@ -83,7 +84,6 @@ lean_object* l_Lean_IR_Checker_checkScalarType(lean_object*, lean_object*, lean_
 lean_object* l_Lean_IR_Checker_checkEqTypes___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkObjType___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkEqTypes___closed__2;
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_Checker_markIndex___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkPartialApp___closed__3;
 lean_object* l_Lean_IR_checkDecls(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at_Lean_IR_checkDecls___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -126,10 +126,10 @@ lean_object* l_Lean_IR_LocalContext_addLocal(lean_object*, lean_object*, lean_ob
 lean_object* l_Array_forMAux___main___at_Lean_IR_Checker_checkArgs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkFullApp___closed__1;
 lean_object* l_Lean_IR_Checker_checkFnBody_match__1___rarg(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_RBNode_findCore___main___at_Lean_IR_Checker_markIndex___spec__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_IR_VarId_Lean_Compiler_IR_Basic___instance__2___closed__1;
 lean_object* l_Lean_IR_Checker_getDecl_match__1(lean_object*);
 lean_object* l_Lean_IR_checkDecl_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_Checker_markIndex___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkArgs(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Checker_checkVar(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at_Lean_IR_Checker_checkFnBody___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -176,7 +176,7 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_Checker_markIndex___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_Checker_markIndex___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -256,7 +256,7 @@ lean_object* l_Lean_IR_Checker_markIndex(lean_object* x_1, lean_object* x_2, lea
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___at_Lean_IR_Checker_markIndex___spec__1(x_3, x_1);
+x_4 = l_Std_RBNode_findCore___at_Lean_IR_Checker_markIndex___spec__1(x_3, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; 
@@ -283,11 +283,11 @@ return x_13;
 }
 }
 }
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_Checker_markIndex___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_Checker_markIndex___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_findCore___main___at_Lean_IR_Checker_markIndex___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_findCore___at_Lean_IR_Checker_markIndex___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Compiler/IR/CompilerM.c b/stage0/stdlib/Lean/Compiler/IR/CompilerM.c
index 520d3a644b..526cffd716 100644
--- a/stage0/stdlib/Lean/Compiler/IR/CompilerM.c
+++ b/stage0/stdlib/Lean/Compiler/IR/CompilerM.c
@@ -43,7 +43,6 @@ extern lean_object* l_Array_empty___closed__1;
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_mkEntryArray___spec__10(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_findDecl_x27___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_findCore___main(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_IR_initFn____x40_Lean_Compiler_IR_CompilerM___hyg_335____spec__5(size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_initFn____x40_Lean_Compiler_IR_CompilerM___hyg_335_(lean_object*);
 lean_object* l_Lean_IR_log___boxed(lean_object*, lean_object*, lean_object*);
@@ -191,6 +190,7 @@ lean_object* l_Lean_IR_getDecl_match__1(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_logDeclsAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_addDecl(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LogEntry_Lean_Compiler_IR_CompilerM___instance__1;
+lean_object* l_Lean_KVMap_findCore(lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_IR_initFn____x40_Lean_Compiler_IR_CompilerM___hyg_335____spec__12___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Log_format___boxed(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_isLogEnabledFor_match__1(lean_object*);
@@ -622,7 +622,7 @@ uint8_t l___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_isLogEnabledFor(lean_o
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_3 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; uint8_t x_5; uint8_t x_6; 
@@ -1798,54 +1798,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_IR_initFn____x40_Lean_Compiler_IR_CompilerM___hyg_335____spec__2(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_IR_initFn____x40_Lean_Compiler_IR_CompilerM___hyg_335____spec__2(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_IR_initFn____x40_Lean_Compiler_IR_CompilerM___hyg_335____spec__2(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_mkEntryArray___spec__2(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_mkEntryArray___spec__2(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_mkEntryArray___spec__2(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at___private_Lean_Compiler_IR_CompilerM_0__Lean_IR_mkEntryArray___spec__2(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Compiler/IR/CtorLayout.c b/stage0/stdlib/Lean/Compiler/IR/CtorLayout.c
index 0b8ab45dc1..90752d4cf0 100644
--- a/stage0/stdlib/Lean/Compiler/IR/CtorLayout.c
+++ b/stage0/stdlib/Lean/Compiler/IR/CtorLayout.c
@@ -14,8 +14,8 @@
 extern "C" {
 #endif
 lean_object* l_Lean_IR_CtorFieldInfo_format___closed__7;
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_IR_CtorFieldInfo_Lean_Compiler_IR_CtorLayout___instance__1;
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_Lean_IR_CtorFieldInfo_format_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_CtorFieldInfo_format___closed__6;
 lean_object* l_Lean_fmt___at_Lean_IR_CtorFieldInfo_format___spec__1(lean_object*);
@@ -196,7 +196,7 @@ 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);
 lean_inc(x_3);
 lean_dec(x_1);
-x_4 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_3);
+x_4 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_3);
 x_5 = l_Lean_IR_CtorFieldInfo_format___closed__2;
 x_6 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_6, 0, x_5);
@@ -213,7 +213,7 @@ lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_
 x_9 = lean_ctor_get(x_1, 0);
 lean_inc(x_9);
 lean_dec(x_1);
-x_10 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_9);
+x_10 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_9);
 x_11 = l_Lean_IR_CtorFieldInfo_format___closed__4;
 x_12 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_12, 0, x_11);
@@ -234,7 +234,7 @@ lean_inc(x_16);
 x_17 = lean_ctor_get(x_1, 2);
 lean_inc(x_17);
 lean_dec(x_1);
-x_18 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_15);
+x_18 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_15);
 x_19 = l_Lean_IR_CtorFieldInfo_format___closed__6;
 x_20 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_20, 0, x_19);
@@ -243,7 +243,7 @@ x_21 = l_Lean_IR_CtorFieldInfo_format___closed__8;
 x_22 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_22, 0, x_20);
 lean_ctor_set(x_22, 1, x_21);
-x_23 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_16);
+x_23 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_16);
 x_24 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_24, 0, x_22);
 lean_ctor_set(x_24, 1, x_23);
diff --git a/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c b/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c
index 8b934267b8..d3acd56d78 100644
--- a/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c
+++ b/stage0/stdlib/Lean/Compiler/IR/ElimDeadBranches.c
@@ -3686,54 +3686,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_IR_UnreachableBranches_mkFunctionSummariesExtension___spec__2(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_IR_UnreachableBranches_mkFunctionSummariesExtension___spec__2(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_IR_UnreachableBranches_mkFunctionSummariesExtension___spec__2(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_IR_UnreachableBranches_mkFunctionSummariesExtension___spec__6(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_IR_UnreachableBranches_mkFunctionSummariesExtension___spec__6(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_IR_UnreachableBranches_mkFunctionSummariesExtension___spec__6(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_IR_UnreachableBranches_mkFunctionSummariesExtension___spec__6(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Compiler/IR/ElimDeadVars.c b/stage0/stdlib/Lean/Compiler/IR/ElimDeadVars.c
index 59f255cbe8..537f55645f 100644
--- a/stage0/stdlib/Lean/Compiler/IR/ElimDeadVars.c
+++ b/stage0/stdlib/Lean/Compiler/IR/ElimDeadVars.c
@@ -16,6 +16,7 @@ extern "C" {
 extern lean_object* l_Lean_IR_Lean_Compiler_IR_Basic___instance__11;
 lean_object* l_Lean_IR_FnBody_elimDead(lean_object*);
 lean_object* l_Lean_IR_FnBody_elimDead_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_reshapeWithoutDeadAux_match__2(lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
@@ -27,7 +28,6 @@ lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_FnBody_freeIndices(lean_object*);
 lean_object* l_Lean_IR_FnBody_elimDead_match__2(lean_object*);
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(lean_object*, lean_object*);
 uint8_t l_Array_isEmpty___rarg(lean_object*);
 lean_object* l_Lean_IR_reshapeWithoutDeadAux_match__1(lean_object*);
 lean_object* l_Lean_IR_reshapeWithoutDeadAux(lean_object*, lean_object*, lean_object*);
@@ -152,7 +152,7 @@ case 0:
 lean_object* x_7; lean_object* x_8; 
 x_7 = lean_ctor_get(x_5, 0);
 lean_inc(x_7);
-x_8 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_3, x_7);
+x_8 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_3, x_7);
 lean_dec(x_7);
 if (lean_obj_tag(x_8) == 0)
 {
@@ -178,7 +178,7 @@ case 1:
 lean_object* x_13; lean_object* x_14; 
 x_13 = lean_ctor_get(x_5, 0);
 lean_inc(x_13);
-x_14 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_3, x_13);
+x_14 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_3, x_13);
 lean_dec(x_13);
 if (lean_obj_tag(x_14) == 0)
 {
diff --git a/stage0/stdlib/Lean/Compiler/IR/EmitUtil.c b/stage0/stdlib/Lean/Compiler/IR/EmitUtil.c
index eb8dc14761..86124d6c9e 100644
--- a/stage0/stdlib/Lean/Compiler/IR/EmitUtil.c
+++ b/stage0/stdlib/Lean/Compiler/IR/EmitUtil.c
@@ -33,7 +33,7 @@ lean_object* l_Array_forMAux___main___at_Lean_IR_CollectUsedDecls_collectFnBody_
 lean_object* l_Lean_IR_CollectUsedDecls_collectInitDecl_match__1(lean_object*);
 lean_object* l_List_foldr___main___at_Lean_IR_usesModuleFrom___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
-lean_object* l_Std_RBNode_revFold___main___at_Lean_IR_usesModuleFrom___spec__2(lean_object*, lean_object*);
+uint8_t l_Lean_Name_isPrefixOf(lean_object*, lean_object*);
 lean_object* l_Lean_IR_CollectUsedDecls_collectFnBody(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_CollectUsedDecls_collectInitDecl_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_foldlM___at_Lean_IR_CollectMaps_collectVar___spec__5(lean_object*, lean_object*);
@@ -51,12 +51,10 @@ uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_IR_CollectMaps_collectFnBody_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_CollectMaps_collectVar_match__1(lean_object*);
 lean_object* l_Std_mkHashMap___at_Lean_IR_mkVarJPMaps___spec__2(lean_object*);
-lean_object* l_Std_RBNode_revFold___main___at_Lean_IR_usesModuleFrom___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_IR_CollectMaps_collectFnBody___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_mkHashMapImp___rarg(lean_object*);
 uint8_t l_Lean_IR_FnBody_isTerminal(lean_object*);
-uint8_t l_Lean_Name_isPrefixOf___main(lean_object*, lean_object*);
 lean_object* l_Std_AssocList_replace___at_Lean_IR_CollectMaps_collectJP___spec__6(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___at_Lean_IR_CollectMaps_collectJP___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_expand___at_Lean_IR_CollectMaps_collectVar___spec__3(lean_object*, lean_object*);
@@ -64,7 +62,9 @@ lean_object* l_Lean_IR_CollectUsedDecls_collect(lean_object*, lean_object*, lean
 size_t lean_usize_modn(size_t, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 uint8_t l_List_foldr___main___at_Lean_IR_usesModuleFrom___spec__3(lean_object*, uint8_t, lean_object*);
+lean_object* l_Std_RBNode_revFold___at_Lean_IR_usesModuleFrom___spec__2(lean_object*, lean_object*);
 uint8_t l_Std_AssocList_contains___at_Lean_IR_CollectMaps_collectVar___spec__2(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_revFold___at_Lean_IR_usesModuleFrom___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_CollectMaps_collectJP(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_CollectMaps_collectVar_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_toList___at_Lean_IR_usesModuleFrom___spec__1(lean_object*);
@@ -261,7 +261,7 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_revFold___main___at_Lean_IR_usesModuleFrom___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_revFold___at_Lean_IR_usesModuleFrom___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -274,7 +274,7 @@ lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_obj
 x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 3);
-x_6 = l_Std_RBNode_revFold___main___at_Lean_IR_usesModuleFrom___spec__2(x_1, x_5);
+x_6 = l_Std_RBNode_revFold___at_Lean_IR_usesModuleFrom___spec__2(x_1, x_5);
 lean_inc(x_4);
 x_7 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_7, 0, x_4);
@@ -290,7 +290,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = lean_box(0);
-x_3 = l_Std_RBNode_revFold___main___at_Lean_IR_usesModuleFrom___spec__2(x_2, x_1);
+x_3 = l_Std_RBNode_revFold___at_Lean_IR_usesModuleFrom___spec__2(x_2, x_1);
 return x_3;
 }
 }
@@ -307,7 +307,7 @@ lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7;
 x_4 = lean_ctor_get(x_3, 0);
 x_5 = lean_ctor_get(x_3, 1);
 x_6 = l_List_foldr___main___at_Lean_IR_usesModuleFrom___spec__3(x_1, x_2, x_5);
-x_7 = l_Lean_Name_isPrefixOf___main(x_1, x_4);
+x_7 = l_Lean_Name_isPrefixOf(x_1, x_4);
 if (x_7 == 0)
 {
 return x_6;
@@ -334,11 +334,11 @@ lean_dec(x_4);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_revFold___main___at_Lean_IR_usesModuleFrom___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_revFold___at_Lean_IR_usesModuleFrom___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_revFold___main___at_Lean_IR_usesModuleFrom___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_revFold___at_Lean_IR_usesModuleFrom___spec__2(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
diff --git a/stage0/stdlib/Lean/Compiler/IR/Format.c b/stage0/stdlib/Lean/Compiler/IR/Format.c
index aa95826fc7..91cfd6d959 100644
--- a/stage0/stdlib/Lean/Compiler/IR/Format.c
+++ b/stage0/stdlib/Lean/Compiler/IR/Format.c
@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* l_Lean_IR_litValHasFormat___closed__1;
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_IR_typeHasToString;
 lean_object* l_Lean_IR_formatFnBodyHead___closed__15;
 lean_object* l___private_Lean_Compiler_IR_Format_0__Lean_IR_formatCtorInfo___closed__1;
@@ -58,6 +57,7 @@ lean_object* l_Lean_IR_formatAlt___closed__4;
 lean_object* l___private_Lean_Compiler_IR_Format_0__Lean_IR_formatIRType___closed__22;
 lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_Format_0__Lean_IR_formatExpr___closed__25;
 extern lean_object* l_Lean_formatKVMap___closed__1;
 lean_object* l_Lean_IR_formatArray___at_Lean_IR_formatParams___spec__1(lean_object*);
@@ -593,7 +593,7 @@ lean_inc(x_4);
 x_5 = lean_ctor_get(x_1, 4);
 lean_inc(x_5);
 lean_dec(x_1);
-x_6 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_3);
+x_6 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_3);
 x_7 = l___private_Lean_Compiler_IR_Format_0__Lean_IR_formatCtorInfo___closed__2;
 x_8 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_8, 0, x_7);
@@ -627,14 +627,14 @@ x_17 = l___private_Lean_Compiler_IR_Format_0__Lean_IR_formatCtorInfo___closed__3
 x_18 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_18, 0, x_16);
 lean_ctor_set(x_18, 1, x_17);
-x_19 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_4);
+x_19 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_4);
 x_20 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_20, 0, x_18);
 lean_ctor_set(x_20, 1, x_19);
 x_21 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_21, 0, x_20);
 lean_ctor_set(x_21, 1, x_17);
-x_22 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_5);
+x_22 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_5);
 x_23 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_23, 0, x_21);
 lean_ctor_set(x_23, 1, x_22);
@@ -656,14 +656,14 @@ x_28 = l___private_Lean_Compiler_IR_Format_0__Lean_IR_formatCtorInfo___closed__3
 x_29 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_29, 0, x_27);
 lean_ctor_set(x_29, 1, x_28);
-x_30 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_4);
+x_30 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_4);
 x_31 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_31, 0, x_29);
 lean_ctor_set(x_31, 1, x_30);
 x_32 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_32, 0, x_31);
 lean_ctor_set(x_32, 1, x_28);
-x_33 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_5);
+x_33 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_5);
 x_34 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_34, 0, x_32);
 lean_ctor_set(x_34, 1, x_33);
diff --git a/stage0/stdlib/Lean/Compiler/IR/FreeVars.c b/stage0/stdlib/Lean/Compiler/IR/FreeVars.c
index ffb8d707b4..64bfd48ebd 100644
--- a/stage0/stdlib/Lean/Compiler/IR/FreeVars.c
+++ b/stage0/stdlib/Lean/Compiler/IR/FreeVars.c
@@ -26,6 +26,7 @@ lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_withPa
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectArgs___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_IR_FreeIndices_insertParams___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectAlts___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_MaxIndex_collectJP(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectArray___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectArg(lean_object*, lean_object*, lean_object*);
@@ -90,7 +91,6 @@ lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_FreeVars
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_skip___boxed(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_MaxIndex_collectAlts___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_FreeIndices_collectFnBody(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_skip(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_MaxIndex_collectArray___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_MaxIndex_collectParams___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_MaxIndex_collectParam___boxed(lean_object*, lean_object*);
@@ -107,6 +107,7 @@ lean_object* l_Lean_IR_HasIndex_visitArg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_FreeIndices_insertParams(lean_object*, lean_object*);
 lean_object* l_Lean_IR_MaxIndex_Lean_Compiler_IR_FreeVars___instance__1;
 lean_object* l_Array_anyRangeMAux___main___at_Lean_IR_HasIndex_visitArgs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_HasIndex_visitArgs___boxed(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_MaxIndex_collectParams___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_withJP(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -116,7 +117,6 @@ lean_object* l_Lean_IR_FreeIndices_collectFnBody___closed__1;
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectArray___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectArgs___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectExpr_match__1___rarg(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_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_IR_HasIndex_visitArg(lean_object*, lean_object*);
 uint8_t l_Lean_IR_HasIndex_visitArgs(lean_object*, lean_object*);
 lean_object* l_Lean_IR_HasIndex_visitExpr_match__1(lean_object*);
@@ -2018,7 +2018,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -2069,7 +2069,7 @@ lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collec
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_1);
+x_4 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; 
@@ -2085,11 +2085,11 @@ return x_3;
 }
 }
 }
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -2108,7 +2108,7 @@ lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collec
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_1);
+x_4 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; 
@@ -2137,7 +2137,7 @@ lean_object* l___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collec
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_1);
+x_4 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_1);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; 
@@ -2334,7 +2334,7 @@ lean_object* x_4; lean_object* x_5;
 x_4 = lean_ctor_get(x_1, 0);
 lean_inc(x_4);
 lean_dec(x_1);
-x_5 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_4);
+x_5 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_4);
 if (lean_obj_tag(x_5) == 0)
 {
 lean_object* x_6; lean_object* x_7; 
@@ -2849,7 +2849,7 @@ lean_inc(x_7);
 x_8 = lean_ctor_get(x_1, 2);
 lean_inc(x_8);
 lean_dec(x_1);
-x_9 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_7);
+x_9 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_7);
 if (lean_obj_tag(x_9) == 0)
 {
 lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
@@ -2877,7 +2877,7 @@ lean_object* x_16; lean_object* x_17;
 x_16 = lean_ctor_get(x_1, 2);
 lean_inc(x_16);
 lean_dec(x_1);
-x_17 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_16);
+x_17 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_16);
 if (lean_obj_tag(x_17) == 0)
 {
 lean_object* x_18; lean_object* x_19; 
@@ -2922,7 +2922,7 @@ lean_inc(x_26);
 x_27 = lean_ctor_get(x_1, 1);
 lean_inc(x_27);
 lean_dec(x_1);
-x_28 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_26);
+x_28 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_26);
 if (lean_obj_tag(x_28) == 0)
 {
 lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
@@ -2950,7 +2950,7 @@ lean_object* x_35; lean_object* x_36;
 x_35 = lean_ctor_get(x_1, 0);
 lean_inc(x_35);
 lean_dec(x_1);
-x_36 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_35);
+x_36 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_35);
 if (lean_obj_tag(x_36) == 0)
 {
 lean_object* x_37; lean_object* x_38; 
@@ -2976,7 +2976,7 @@ lean_object* x_39; lean_object* x_40;
 x_39 = lean_ctor_get(x_1, 0);
 lean_inc(x_39);
 lean_dec(x_1);
-x_40 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_39);
+x_40 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_39);
 if (lean_obj_tag(x_40) == 0)
 {
 lean_object* x_41; lean_object* x_42; 
@@ -2997,7 +2997,7 @@ lean_object* x_43; lean_object* x_44;
 x_43 = lean_ctor_get(x_1, 0);
 lean_inc(x_43);
 lean_dec(x_1);
-x_44 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_43);
+x_44 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_43);
 if (lean_obj_tag(x_44) == 0)
 {
 lean_object* x_45; lean_object* x_46; 
@@ -3018,7 +3018,7 @@ lean_object* x_47; lean_object* x_48;
 x_47 = lean_ctor_get(x_1, 1);
 lean_inc(x_47);
 lean_dec(x_1);
-x_48 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_47);
+x_48 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_47);
 if (lean_obj_tag(x_48) == 0)
 {
 lean_object* x_49; lean_object* x_50; 
@@ -3574,7 +3574,7 @@ lean_inc(x_22);
 x_23 = lean_ctor_get(x_1, 3);
 lean_inc(x_23);
 lean_dec(x_1);
-x_24 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_21);
+x_24 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_21);
 if (lean_obj_tag(x_24) == 0)
 {
 lean_object* x_25; lean_object* x_26; lean_object* x_27; 
@@ -3606,7 +3606,7 @@ lean_inc(x_32);
 x_33 = lean_ctor_get(x_1, 3);
 lean_inc(x_33);
 lean_dec(x_1);
-x_42 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_31);
+x_42 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_31);
 if (lean_obj_tag(x_42) == 0)
 {
 lean_object* x_43; lean_object* x_44; 
@@ -3629,7 +3629,7 @@ goto block_41;
 block_41:
 {
 lean_object* x_36; 
-x_36 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_35, x_32);
+x_36 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_35, x_32);
 lean_dec(x_35);
 if (lean_obj_tag(x_36) == 0)
 {
@@ -3660,7 +3660,7 @@ lean_inc(x_46);
 x_47 = lean_ctor_get(x_1, 5);
 lean_inc(x_47);
 lean_dec(x_1);
-x_56 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_45);
+x_56 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_45);
 if (lean_obj_tag(x_56) == 0)
 {
 lean_object* x_57; lean_object* x_58; 
@@ -3683,7 +3683,7 @@ goto block_55;
 block_55:
 {
 lean_object* x_50; 
-x_50 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_49, x_46);
+x_50 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_49, x_46);
 lean_dec(x_49);
 if (lean_obj_tag(x_50) == 0)
 {
@@ -3712,7 +3712,7 @@ lean_inc(x_59);
 x_60 = lean_ctor_get(x_1, 1);
 lean_inc(x_60);
 lean_dec(x_1);
-x_61 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_59);
+x_61 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_59);
 if (lean_obj_tag(x_61) == 0)
 {
 lean_object* x_62; lean_object* x_63; 
@@ -3747,7 +3747,7 @@ lean_inc(x_68);
 x_69 = lean_ctor_get(x_1, 3);
 lean_inc(x_69);
 lean_dec(x_1);
-x_70 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_68);
+x_70 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_68);
 if (lean_obj_tag(x_70) == 0)
 {
 lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
@@ -3789,7 +3789,7 @@ lean_inc(x_81);
 x_82 = lean_ctor_get(x_1, 1);
 lean_inc(x_82);
 lean_dec(x_1);
-x_83 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_81);
+x_83 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_81);
 if (lean_obj_tag(x_83) == 0)
 {
 lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
@@ -3826,7 +3826,7 @@ lean_inc(x_90);
 x_91 = lean_ctor_get(x_1, 2);
 lean_inc(x_91);
 lean_dec(x_1);
-x_92 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_90);
+x_92 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_FreeVars_0__Lean_IR_FreeIndices_collectIndex___spec__1(x_2, x_90);
 if (lean_obj_tag(x_92) == 0)
 {
 lean_object* x_93; lean_object* x_94; 
diff --git a/stage0/stdlib/Lean/Compiler/IR/LiveVars.c b/stage0/stdlib/Lean/Compiler/IR/LiveVars.c
index 830578c906..aae3bff5bb 100644
--- a/stage0/stdlib/Lean/Compiler/IR/LiveVars.c
+++ b/stage0/stdlib/Lean/Compiler/IR/LiveVars.c
@@ -14,6 +14,7 @@
 extern "C" {
 #endif
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectVar(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_erase___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArray___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitArg___boxed(lean_object*, lean_object*, lean_object*);
@@ -22,28 +23,26 @@ lean_object* l_Lean_IR_IsLive_visitFnBody___boxed(lean_object*, lean_object*, le
 lean_object* l_Lean_IR_LiveVars_collectExpr(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArgs(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitExpr___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LiveVars_collectFnBody(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitJP(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_IR_HasIndex_visitExpr(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP_match__1(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LiveVars_collectFnBody_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar(lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitExpr(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArray___at_Lean_IR_LiveVars_collectFnBody___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_IR_IsLive_visitFnBody___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_AltCore_body(lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArray___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArgs___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_IR_collectLiveVars(lean_object*, lean_object*, lean_object*);
@@ -53,20 +52,20 @@ lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_LiveVars
 lean_object* l_Std_PersistentHashMap_forM___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitFnBody_match__2___rarg(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_RBNode_insert___at_Lean_IR_LiveVars_collectFnBody___spec__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitJP___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balRight___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBNode_isBlack___rarg(lean_object*);
 lean_object* l_Array_iterateMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LiveVars_updateJPLiveVarMap___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_erase___at_Lean_IR_LocalContext_eraseJoinPointDecl___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindParams___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitFnBody_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitFnBody_match__2(lean_object*);
 lean_object* l_Std_RBNode_balLeft___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_appendTrees___main___rarg(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArgs___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArray___at_Lean_IR_LiveVars_collectFnBody___spec__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LiveVars_collectFnBody_match__1(lean_object*);
 extern lean_object* l_Id_Monad;
@@ -74,7 +73,7 @@ lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_LiveVars
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate(lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitFnBody(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_LiveVars_collectExpr_match__1(lean_object*);
-lean_object* l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitArgs___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArg_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBNode_isRed___rarg(lean_object*);
@@ -94,9 +93,10 @@ lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindParam
 lean_object* l_Lean_IR_LocalContext_getJPBody(lean_object*, lean_object*);
 lean_object* l_Lean_IR_LiveVars_collectExpr_match__1___rarg(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_Array_iterateMAux___main___at_Lean_IR_LiveVars_collectFnBody___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectArgs___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_IsLive_visitVar___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_FnBody_hasLiveVar___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_skip___boxed(lean_object*);
 lean_object* l_Lean_IR_IsLive_visitVar(lean_object*, lean_object*, lean_object*);
@@ -1131,2380 +1131,2457 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_nat_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_nat_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_nat_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_nat_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_nat_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_nat_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_nat_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_nat_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_nat_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_nat_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_nat_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_nat_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_nat_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_nat_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_nat_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_nat_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -3524,13 +3601,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_IR_mkLiveVarSet___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_IR_mkLiveVarSet___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -3712,7 +3789,7 @@ lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -3729,7 +3806,7 @@ lean_inc(x_5);
 x_6 = lean_ctor_get(x_3, 3);
 lean_inc(x_6);
 lean_dec(x_3);
-x_7 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_1, x_2, x_4);
+x_7 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_1, x_2, x_4);
 x_8 = lean_box(0);
 x_9 = l_Std_RBNode_insert___at_Lean_IR_mkLiveVarSet___spec__1(x_7, x_5, x_8);
 x_2 = x_9;
@@ -3743,15 +3820,15 @@ _start:
 {
 lean_object* x_3; lean_object* x_4; 
 x_3 = l_Lean_Position_lt___closed__2;
-x_4 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_3, x_2, x_1);
+x_4 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_3, x_2, x_1);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_1, x_2, x_3);
 lean_dec(x_1);
 return x_4;
 }
@@ -3787,7 +3864,7 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Compiler_IR_LiveVars_0__Lean_I
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -3834,7 +3911,7 @@ lean_object* l___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(x_1, x_2);
+x_4 = l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 return x_3;
@@ -3846,16 +3923,16 @@ x_5 = lean_ctor_get(x_4, 0);
 lean_inc(x_5);
 lean_dec(x_4);
 x_6 = l_Lean_Position_lt___closed__2;
-x_7 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_6, x_3, x_5);
+x_7 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_accumulate___spec__1(x_6, x_3, x_5);
 return x_7;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -3871,158 +3948,160 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
 {
-return x_2;
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
 }
 else
 {
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_2);
+if (x_4 == 0)
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = lean_ctor_get(x_2, 1);
-x_6 = lean_ctor_get(x_2, 2);
-x_7 = lean_ctor_get(x_2, 3);
-x_8 = lean_nat_dec_lt(x_1, x_5);
-if (x_8 == 0)
-{
-uint8_t x_9; 
-x_9 = lean_nat_dec_lt(x_5, x_1);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_ctor_get(x_2, 1);
+x_7 = lean_ctor_get(x_2, 2);
+x_8 = lean_ctor_get(x_2, 3);
+x_9 = lean_nat_dec_lt(x_1, x_6);
 if (x_9 == 0)
 {
-lean_object* x_10; 
+uint8_t x_10; 
+x_10 = lean_nat_dec_lt(x_6, x_1);
+if (x_10 == 0)
+{
+lean_object* x_11; 
 lean_free_object(x_2);
+lean_dec(x_7);
 lean_dec(x_6);
-lean_dec(x_5);
-x_10 = l_Std_RBNode_appendTrees___main___rarg(x_4, x_7);
-return x_10;
+x_11 = l_Std_RBNode_appendTrees___rarg(x_5, x_8);
+return x_11;
 }
 else
 {
-uint8_t x_11; 
-x_11 = l_Std_RBNode_isBlack___rarg(x_7);
-if (x_11 == 0)
+uint8_t x_12; 
+x_12 = l_Std_RBNode_isBlack___rarg(x_8);
+if (x_12 == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-x_12 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_7);
-x_13 = 0;
-lean_ctor_set(x_2, 3, x_12);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_13);
+lean_object* x_13; uint8_t x_14; 
+x_13 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_8);
+x_14 = 0;
+lean_ctor_set(x_2, 3, x_13);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_14);
 return x_2;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; 
+lean_object* x_15; lean_object* x_16; 
 lean_free_object(x_2);
-x_14 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_7);
-x_15 = l_Std_RBNode_balRight___rarg(x_4, x_5, x_6, x_14);
-return x_15;
+x_15 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_8);
+x_16 = l_Std_RBNode_balRight___rarg(x_5, x_6, x_7, x_15);
+return x_16;
 }
 }
 }
 else
 {
-uint8_t x_16; 
-x_16 = l_Std_RBNode_isBlack___rarg(x_4);
-if (x_16 == 0)
+uint8_t x_17; 
+x_17 = l_Std_RBNode_isBlack___rarg(x_5);
+if (x_17 == 0)
 {
-lean_object* x_17; uint8_t x_18; 
-x_17 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_4);
-x_18 = 0;
-lean_ctor_set(x_2, 0, x_17);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_18);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_5);
+x_19 = 0;
+lean_ctor_set(x_2, 0, x_18);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_19);
 return x_2;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; 
+lean_object* x_20; lean_object* x_21; 
 lean_free_object(x_2);
-x_19 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_4);
-x_20 = l_Std_RBNode_balLeft___rarg(x_19, x_5, x_6, x_7);
-return x_20;
+x_20 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_5);
+x_21 = l_Std_RBNode_balLeft___rarg(x_20, x_6, x_7, x_8);
+return x_21;
 }
 }
 }
 else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_21 = lean_ctor_get(x_2, 0);
-x_22 = lean_ctor_get(x_2, 1);
-x_23 = lean_ctor_get(x_2, 2);
-x_24 = lean_ctor_get(x_2, 3);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_22 = lean_ctor_get(x_2, 0);
+x_23 = lean_ctor_get(x_2, 1);
+x_24 = lean_ctor_get(x_2, 2);
+x_25 = lean_ctor_get(x_2, 3);
+lean_inc(x_25);
 lean_inc(x_24);
 lean_inc(x_23);
 lean_inc(x_22);
-lean_inc(x_21);
 lean_dec(x_2);
-x_25 = lean_nat_dec_lt(x_1, x_22);
-if (x_25 == 0)
-{
-uint8_t x_26; 
-x_26 = lean_nat_dec_lt(x_22, x_1);
+x_26 = lean_nat_dec_lt(x_1, x_23);
 if (x_26 == 0)
 {
-lean_object* x_27; 
+uint8_t x_27; 
+x_27 = lean_nat_dec_lt(x_23, x_1);
+if (x_27 == 0)
+{
+lean_object* x_28; 
+lean_dec(x_24);
 lean_dec(x_23);
-lean_dec(x_22);
-x_27 = l_Std_RBNode_appendTrees___main___rarg(x_21, x_24);
-return x_27;
+x_28 = l_Std_RBNode_appendTrees___rarg(x_22, x_25);
+return x_28;
 }
 else
 {
-uint8_t x_28; 
-x_28 = l_Std_RBNode_isBlack___rarg(x_24);
-if (x_28 == 0)
+uint8_t x_29; 
+x_29 = l_Std_RBNode_isBlack___rarg(x_25);
+if (x_29 == 0)
 {
-lean_object* x_29; uint8_t x_30; lean_object* x_31; 
-x_29 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_24);
-x_30 = 0;
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_21);
-lean_ctor_set(x_31, 1, x_22);
-lean_ctor_set(x_31, 2, x_23);
-lean_ctor_set(x_31, 3, x_29);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_30);
-return x_31;
+lean_object* x_30; uint8_t x_31; lean_object* x_32; 
+x_30 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_25);
+x_31 = 0;
+x_32 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_32, 0, x_22);
+lean_ctor_set(x_32, 1, x_23);
+lean_ctor_set(x_32, 2, x_24);
+lean_ctor_set(x_32, 3, x_30);
+lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31);
+return x_32;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_24);
-x_33 = l_Std_RBNode_balRight___rarg(x_21, x_22, x_23, x_32);
-return x_33;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_25);
+x_34 = l_Std_RBNode_balRight___rarg(x_22, x_23, x_24, x_33);
+return x_34;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = l_Std_RBNode_isBlack___rarg(x_21);
-if (x_34 == 0)
+uint8_t x_35; 
+x_35 = l_Std_RBNode_isBlack___rarg(x_22);
+if (x_35 == 0)
 {
-lean_object* x_35; uint8_t x_36; lean_object* x_37; 
-x_35 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_21);
-x_36 = 0;
-x_37 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_22);
-lean_ctor_set(x_37, 2, x_23);
-lean_ctor_set(x_37, 3, x_24);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
-return x_37;
+lean_object* x_36; uint8_t x_37; lean_object* x_38; 
+x_36 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_22);
+x_37 = 0;
+x_38 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_23);
+lean_ctor_set(x_38, 2, x_24);
+lean_ctor_set(x_38, 3, x_25);
+lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_37);
+return x_38;
 }
 else
 {
-lean_object* x_38; lean_object* x_39; 
-x_38 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_21);
-x_39 = l_Std_RBNode_balLeft___rarg(x_38, x_22, x_23, x_24);
-return x_39;
+lean_object* x_39; lean_object* x_40; 
+x_39 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_22);
+x_40 = l_Std_RBNode_balLeft___rarg(x_39, x_23, x_24, x_25);
+return x_40;
 }
 }
 }
@@ -4033,7 +4112,7 @@ lean_object* l_Std_RBNode_erase___at___private_Lean_Compiler_IR_LiveVars_0__Lean
 _start:
 {
 lean_object* x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_2);
 x_4 = l_Std_RBNode_setBlack___rarg(x_3);
 return x_4;
 }
@@ -4046,11 +4125,11 @@ x_3 = l_Std_RBNode_erase___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_Liv
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_del___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__2(x_1, x_2);
 lean_dec(x_1);
 return x_3;
 }
@@ -4991,2380 +5070,2457 @@ x_2 = lean_alloc_closure((void*)(l_Lean_IR_LiveVars_collectFnBody_match__1___rar
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_nat_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_nat_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_nat_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_nat_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_nat_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_nat_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_nat_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_nat_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_nat_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_nat_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_nat_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_nat_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_nat_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_nat_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_nat_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_nat_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -7384,13 +7540,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_IR_LiveVars_collectFnBody___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
diff --git a/stage0/stdlib/Lean/Compiler/IR/NormIds.c b/stage0/stdlib/Lean/Compiler/IR/NormIds.c
index ceec25de6d..a1d99d335f 100644
--- a/stage0/stdlib/Lean/Compiler/IR/NormIds.c
+++ b/stage0/stdlib/Lean/Compiler/IR/NormIds.c
@@ -21,7 +21,6 @@ lean_object* l_Lean_IR_UniqueIds_checkFnBody_match__1(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_FnBody_replaceVar___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normJP___boxed(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_FnBody_replaceVar___spec__15___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_NormalizeIds_normFnBody___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normDecl_match__1(lean_object*);
 lean_object* l_Lean_IR_MapVars_mapArgs(lean_object*, lean_object*);
@@ -29,6 +28,7 @@ lean_object* l_Lean_IR_MapVars_mapArgs___at_Lean_IR_FnBody_replaceVar___spec__11
 lean_object* l_Array_anyRangeMAux___main___at_Lean_IR_UniqueIds_checkFnBody___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_MapVars_mapArgs___at_Lean_IR_FnBody_replaceVar___spec__3___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normExpr___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normFnBody_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_NormalizeIds_normArgs___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_UniqueIds_checkFnBody(lean_object*, lean_object*);
@@ -101,14 +101,12 @@ lean_object* l_Lean_IR_UniqueIds_checkId(lean_object*, lean_object*);
 lean_object* l_Lean_IR_MapVars_mapExpr___at_Lean_IR_FnBody_replaceVar___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_NormalizeIds_normFnBody___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_FnBody_replaceVar___spec__10(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normJP(lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normArg_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_MapVars_mapExpr___at_Lean_IR_FnBody_replaceVar___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_FnBody_replaceVar___spec__12___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_MapVars_mapArgs___at_Lean_IR_FnBody_replaceVar___spec__9___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_MapVars_mapArgs___at_Lean_IR_FnBody_replaceVar___spec__3(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_withParams(lean_object*);
 lean_object* l_Lean_IR_MapVars_mapArg(lean_object*, lean_object*);
 lean_object* l_Lean_IR_MapVars_mapArgs___at_Lean_IR_FnBody_replaceVar___spec__14___boxed(lean_object*, lean_object*, lean_object*);
@@ -116,6 +114,7 @@ lean_object* l_Lean_IR_Decl_uniqueIds(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_NormalizeIds_normDecl___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_Decl_normalizeIds(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_NormalizeIds_withParams___spec__2___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_MapVars_mapArgs___at_Lean_IR_FnBody_replaceVar___spec__7(lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normArgs(lean_object*, lean_object*);
@@ -125,6 +124,7 @@ lean_object* l_Lean_IR_FnBody_body(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_IR_NormalizeIds_withParams___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_UniqueIds_checkDecl(lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normIndex(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_FnBody_replaceVar___spec__8___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_withJP___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_NormalizeIds_normIndex___boxed(lean_object*, lean_object*);
@@ -141,7 +141,7 @@ lean_object* l_Std_RBNode_insert___at_Lean_IR_mkIndexSet___spec__1(lean_object*,
 lean_object* l_Lean_IR_MapVars_mapFnBody_match__1___rarg(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_Array_umapMAux___main___at_Lean_IR_NormalizeIds_normDecl___spec__2(lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -192,7 +192,7 @@ lean_object* l_Lean_IR_UniqueIds_checkId(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_2, x_1);
+x_3 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_2, x_1);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; 
@@ -219,11 +219,11 @@ return x_11;
 }
 }
 }
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -947,7 +947,7 @@ lean_object* l_Lean_IR_NormalizeIds_normIndex(lean_object* x_1, lean_object* x_2
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_VarId_alphaEqv___spec__1(x_2, x_1);
+x_3 = l_Std_RBNode_find___at_Lean_IR_VarId_alphaEqv___spec__1(x_2, x_1);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_inc(x_1);
diff --git a/stage0/stdlib/Lean/Compiler/IR/PushProj.c b/stage0/stdlib/Lean/Compiler/IR/PushProj.c
index eed60209a9..13c23ae7bb 100644
--- a/stage0/stdlib/Lean/Compiler/IR/PushProj.c
+++ b/stage0/stdlib/Lean/Compiler/IR/PushProj.c
@@ -24,6 +24,7 @@ lean_object* l_Array_back___at_Lean_IR_pushProjs___spec__1___boxed(lean_object*)
 lean_object* l_Lean_IR_pushProjs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_reverseAux___main___rarg(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_FnBody_pushProj___spec__2(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_FnBody_pushProj_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_pushProjs_match__1(lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
@@ -60,7 +61,6 @@ lean_object* l_Lean_IR_FnBody_flatten(lean_object*);
 lean_object* l_Lean_IR_mkIndexSet(lean_object*);
 lean_object* l_Lean_IR_reshape(lean_object*, lean_object*);
 extern lean_object* l_Lean_IR_vsetInh;
-lean_object* l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(lean_object*, lean_object*);
 lean_object* lean_array_pop(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_pushProjs___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_FnBody_pushProj_match__4___rarg(lean_object*, lean_object*);
@@ -278,7 +278,7 @@ lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25;
 x_22 = lean_ctor_get(x_13, 1);
 x_23 = l_Lean_IR_vsetInh;
 x_24 = lean_array_get(x_23, x_1, x_5);
-x_25 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_24, x_4);
+x_25 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_24, x_4);
 lean_dec(x_24);
 if (lean_obj_tag(x_25) == 0)
 {
@@ -306,7 +306,7 @@ lean_inc(x_27);
 lean_dec(x_13);
 x_29 = l_Lean_IR_vsetInh;
 x_30 = lean_array_get(x_29, x_1, x_5);
-x_31 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_30, x_4);
+x_31 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_30, x_4);
 lean_dec(x_30);
 if (lean_obj_tag(x_31) == 0)
 {
@@ -341,7 +341,7 @@ lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39;
 x_36 = lean_ctor_get(x_13, 0);
 x_37 = l_Lean_IR_vsetInh;
 x_38 = lean_array_get(x_37, x_1, x_5);
-x_39 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_38, x_4);
+x_39 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_38, x_4);
 lean_dec(x_38);
 if (lean_obj_tag(x_39) == 0)
 {
@@ -367,7 +367,7 @@ lean_inc(x_41);
 lean_dec(x_13);
 x_42 = l_Lean_IR_vsetInh;
 x_43 = lean_array_get(x_42, x_1, x_5);
-x_44 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_43, x_4);
+x_44 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_43, x_4);
 lean_dec(x_43);
 if (lean_obj_tag(x_44) == 0)
 {
@@ -427,7 +427,7 @@ x_11 = lean_array_fset(x_5, x_4, x_10);
 x_12 = x_9;
 x_13 = lean_unsigned_to_nat(1u);
 x_14 = lean_nat_add(x_4, x_13);
-x_15 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_3);
+x_15 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_3);
 if (lean_obj_tag(x_15) == 0)
 {
 lean_object* x_16; lean_object* x_17; 
@@ -488,7 +488,7 @@ lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25;
 x_22 = lean_ctor_get(x_13, 1);
 x_23 = l_Lean_IR_vsetInh;
 x_24 = lean_array_get(x_23, x_1, x_5);
-x_25 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_24, x_4);
+x_25 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_24, x_4);
 lean_dec(x_24);
 if (lean_obj_tag(x_25) == 0)
 {
@@ -516,7 +516,7 @@ lean_inc(x_27);
 lean_dec(x_13);
 x_29 = l_Lean_IR_vsetInh;
 x_30 = lean_array_get(x_29, x_1, x_5);
-x_31 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_30, x_4);
+x_31 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_30, x_4);
 lean_dec(x_30);
 if (lean_obj_tag(x_31) == 0)
 {
@@ -551,7 +551,7 @@ lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39;
 x_36 = lean_ctor_get(x_13, 0);
 x_37 = l_Lean_IR_vsetInh;
 x_38 = lean_array_get(x_37, x_1, x_5);
-x_39 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_38, x_4);
+x_39 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_38, x_4);
 lean_dec(x_38);
 if (lean_obj_tag(x_39) == 0)
 {
@@ -577,7 +577,7 @@ lean_inc(x_41);
 lean_dec(x_13);
 x_42 = l_Lean_IR_vsetInh;
 x_43 = lean_array_get(x_42, x_1, x_5);
-x_44 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_43, x_4);
+x_44 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_43, x_4);
 lean_dec(x_43);
 if (lean_obj_tag(x_44) == 0)
 {
@@ -637,7 +637,7 @@ x_11 = lean_array_fset(x_5, x_4, x_10);
 x_12 = x_9;
 x_13 = lean_unsigned_to_nat(1u);
 x_14 = lean_nat_add(x_4, x_13);
-x_15 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_3);
+x_15 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_3);
 if (lean_obj_tag(x_15) == 0)
 {
 lean_object* x_16; lean_object* x_17; 
@@ -698,7 +698,7 @@ lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25;
 x_22 = lean_ctor_get(x_13, 1);
 x_23 = l_Lean_IR_vsetInh;
 x_24 = lean_array_get(x_23, x_1, x_5);
-x_25 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_24, x_4);
+x_25 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_24, x_4);
 lean_dec(x_24);
 if (lean_obj_tag(x_25) == 0)
 {
@@ -726,7 +726,7 @@ lean_inc(x_27);
 lean_dec(x_13);
 x_29 = l_Lean_IR_vsetInh;
 x_30 = lean_array_get(x_29, x_1, x_5);
-x_31 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_30, x_4);
+x_31 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_30, x_4);
 lean_dec(x_30);
 if (lean_obj_tag(x_31) == 0)
 {
@@ -761,7 +761,7 @@ lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39;
 x_36 = lean_ctor_get(x_13, 0);
 x_37 = l_Lean_IR_vsetInh;
 x_38 = lean_array_get(x_37, x_1, x_5);
-x_39 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_38, x_4);
+x_39 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_38, x_4);
 lean_dec(x_38);
 if (lean_obj_tag(x_39) == 0)
 {
@@ -787,7 +787,7 @@ lean_inc(x_41);
 lean_dec(x_13);
 x_42 = l_Lean_IR_vsetInh;
 x_43 = lean_array_get(x_42, x_1, x_5);
-x_44 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_43, x_4);
+x_44 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_43, x_4);
 lean_dec(x_43);
 if (lean_obj_tag(x_44) == 0)
 {
@@ -847,7 +847,7 @@ x_11 = lean_array_fset(x_5, x_4, x_10);
 x_12 = x_9;
 x_13 = lean_unsigned_to_nat(1u);
 x_14 = lean_nat_add(x_4, x_13);
-x_15 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_3);
+x_15 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_12, x_3);
 if (lean_obj_tag(x_15) == 0)
 {
 lean_object* x_16; lean_object* x_17; 
@@ -896,7 +896,7 @@ lean_object* x_10; uint8_t x_11; lean_object* x_24;
 lean_dec(x_9);
 x_10 = lean_ctor_get(x_7, 0);
 lean_inc(x_10);
-x_24 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_5, x_10);
+x_24 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_5, x_10);
 if (lean_obj_tag(x_24) == 0)
 {
 uint8_t x_25; 
@@ -951,7 +951,7 @@ lean_object* x_27; uint8_t x_28; lean_object* x_41;
 lean_dec(x_9);
 x_27 = lean_ctor_get(x_7, 0);
 lean_inc(x_27);
-x_41 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_5, x_27);
+x_41 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_5, x_27);
 if (lean_obj_tag(x_41) == 0)
 {
 uint8_t x_42; 
@@ -1006,7 +1006,7 @@ lean_object* x_44; uint8_t x_45; lean_object* x_58;
 lean_dec(x_9);
 x_44 = lean_ctor_get(x_7, 0);
 lean_inc(x_44);
-x_58 = l_Std_RBNode_findCore___main___at_Lean_IR_UniqueIds_checkId___spec__1(x_5, x_44);
+x_58 = l_Std_RBNode_findCore___at_Lean_IR_UniqueIds_checkId___spec__1(x_5, x_44);
 if (lean_obj_tag(x_58) == 0)
 {
 uint8_t x_59; 
diff --git a/stage0/stdlib/Lean/Compiler/IR/RC.c b/stage0/stdlib/Lean/Compiler/IR/RC.c
index 494d1f082d..fe073ae8d6 100644
--- a/stage0/stdlib/Lean/Compiler/IR/RC.c
+++ b/stage0/stdlib/Lean/Compiler/IR/RC.c
@@ -14,6 +14,7 @@
 extern "C" {
 #endif
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecAfterFullApp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__7___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__2(lean_object*);
 uint8_t l_Lean_IR_ExplicitRC_VarInfo_persistent___default;
@@ -32,6 +33,7 @@ lean_object* l_Lean_IR_ExplicitRC_visitDecl(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_IR_LiveVars_collectExpr(lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParam(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__4(lean_object*);
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForDeadParams___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isPersistent(lean_object*);
@@ -52,7 +54,6 @@ lean_object* l_Lean_IR_ExplicitRC_addDec(lean_object*, lean_object*, lean_object
 lean_object* l_Nat_anyAux___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParam___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isFirstOcc___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_IR_LocalContext_getJPParams(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(lean_object*, lean_object*);
 lean_object* l_Nat_foldAux___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeConsumeAll___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
@@ -82,9 +83,7 @@ lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__7(lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParamAux___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore___spec__4(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_getVarInfo___closed__1;
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_getJPLiveVars_match__1(lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParamAux___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
@@ -99,7 +98,6 @@ lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_getNumConsump
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_IR_ExplicitRC_visitFnBody___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__8___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_IR_CtorInfo_isRef(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_consumeExpr___boxed(lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParamAux(lean_object*, lean_object*, lean_object*);
@@ -108,15 +106,15 @@ lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isScalarBoxed
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__11(lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__4___rarg(lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForDeadParams___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_getNumConsumptions___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore___spec__2___lambda__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_Context_jpLiveVarMap___default;
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParamAux___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeConsumeAll___spec__4___rarg___boxed(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParamAux___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeConsumeAll___spec__4(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeAux___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_IR_paramInh;
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParamAux_match__1(lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isScalarBoxedInTaggedPtr(lean_object*);
@@ -165,17 +163,16 @@ uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_getNumConsumptions___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeConsumeAll___spec__2___closed__1;
 uint8_t l_Std_RBNode_isRed___rarg(lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody___closed__1;
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_addInc___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isPersistent_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_erase___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_bindVar___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__10(lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_getDecl(lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_consumeExpr(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(lean_object*, lean_object*);
 uint8_t l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_getNumConsumptions___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeConsumeAll___spec__2___lambda__1(lean_object*);
 lean_object* l_Nat_foldAux___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_IR_ExplicitRC_updateVarInfoWithParams___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__9___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Nat_anyAux___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isPersistent___boxed(lean_object*);
@@ -184,7 +181,9 @@ lean_object* l_Lean_IR_mkLiveVarSet(lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_getDecl_match__1(lean_object*);
 lean_object* l_Std_RBNode_insert___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitDecl_match__1(lean_object*);
+lean_object* l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__6___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_foldAux___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody_match__5(lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -193,7 +192,7 @@ lean_object* l_Lean_IR_ExplicitRC_getVarInfo(lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitDecl_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_updateVarInfoWithParams(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_consumeExpr_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_getNumConsumptions(lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_foldAux___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeConsumeAll___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -201,6 +200,7 @@ lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitFnBody(lean_object*, lean_object*);
 lean_object* l_Lean_IR_explicitRC___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_IR_ExplicitRC_visitDecl_match__2(lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_consumeExpr_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBeforeConsumeAll___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_isBorrowParamAux___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addIncBefore___spec__4___boxed(lean_object*, lean_object*, lean_object*);
@@ -367,7 +367,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_IR_ExplicitRC_getVarInfo_match__1___rarg
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -428,7 +428,7 @@ _start:
 {
 lean_object* x_3; lean_object* x_4; 
 x_3 = lean_ctor_get(x_1, 2);
-x_4 = l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_3, x_2);
+x_4 = l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_3, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; 
@@ -445,11 +445,11 @@ return x_6;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -564,7 +564,7 @@ _start:
 {
 lean_object* x_3; lean_object* x_4; 
 x_3 = lean_ctor_get(x_1, 3);
-x_4 = l_Std_RBNode_find___main___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(x_3, x_2);
+x_4 = l_Std_RBNode_find___at___private_Lean_Compiler_IR_LiveVars_0__Lean_IR_LiveVars_collectJP___spec__1(x_3, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; 
@@ -721,2380 +721,2457 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Compiler_IR_RC_0__Lean_IR_Expl
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_nat_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_nat_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_nat_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_nat_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_nat_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_nat_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_nat_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_nat_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_nat_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_nat_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_nat_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_nat_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_nat_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_nat_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_nat_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_nat_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -3114,13 +3191,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_updateRefUsingCtorInfo___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -3139,7 +3216,7 @@ if (x_5 == 0)
 {
 lean_object* x_6; lean_object* x_7; 
 x_6 = lean_ctor_get(x_1, 2);
-x_7 = l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_6, x_2);
+x_7 = l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_6, x_2);
 if (lean_obj_tag(x_7) == 0)
 {
 lean_dec(x_2);
@@ -3192,7 +3269,7 @@ lean_inc(x_19);
 lean_inc(x_18);
 lean_inc(x_17);
 lean_dec(x_1);
-x_22 = l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_19, x_2);
+x_22 = l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_19, x_2);
 if (lean_obj_tag(x_22) == 0)
 {
 lean_object* x_23; 
@@ -3255,7 +3332,7 @@ lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -3302,7 +3379,7 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 if (lean_obj_tag(x_5) == 0)
@@ -3315,8 +3392,8 @@ lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_obj
 x_6 = lean_ctor_get(x_5, 0);
 x_7 = lean_ctor_get(x_5, 1);
 x_8 = lean_ctor_get(x_5, 3);
-x_9 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_2, x_3, x_4, x_6);
-x_10 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_2, x_7);
+x_9 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_2, x_3, x_4, x_6);
+x_10 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_2, x_7);
 if (lean_obj_tag(x_10) == 0)
 {
 uint8_t x_11; 
@@ -3362,25 +3439,25 @@ _start:
 {
 lean_object* x_5; lean_object* x_6; 
 x_5 = l_Lean_Position_lt___closed__2;
-x_6 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_3, x_5, x_4, x_2);
+x_6 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_3, x_5, x_4, x_2);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; 
-x_6 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_2, x_3, x_4, x_5);
+x_6 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_2, x_3, x_4, x_5);
 lean_dec(x_5);
 lean_dec(x_3);
 lean_dec(x_2);
@@ -3953,7 +4030,7 @@ else
 lean_object* x_19; lean_object* x_20; 
 x_19 = l_Lean_Position_lt___closed__2;
 lean_inc(x_9);
-x_20 = l_Std_RBNode_findCore___main___rarg(x_19, x_4, x_9);
+x_20 = l_Std_RBNode_findCore___rarg(x_19, x_4, x_9);
 if (lean_obj_tag(x_20) == 0)
 {
 uint8_t x_21; 
@@ -4371,7 +4448,7 @@ goto _start;
 else
 {
 lean_object* x_27; 
-x_27 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_4, x_16);
+x_27 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_4, x_16);
 if (lean_obj_tag(x_27) == 0)
 {
 uint8_t x_28; 
@@ -4693,7 +4770,7 @@ goto _start;
 else
 {
 lean_object* x_22; 
-x_22 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_4, x_15);
+x_22 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_4, x_15);
 if (lean_obj_tag(x_22) == 0)
 {
 lean_object* x_23; uint8_t x_24; uint8_t x_25; lean_object* x_26; 
@@ -4985,7 +5062,7 @@ goto _start;
 else
 {
 lean_object* x_26; 
-x_26 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_3, x_15);
+x_26 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_3, x_15);
 if (lean_obj_tag(x_26) == 0)
 {
 uint8_t x_27; 
@@ -5261,7 +5338,7 @@ goto _start;
 else
 {
 lean_object* x_17; 
-x_17 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_3, x_10);
+x_17 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_3, x_10);
 if (lean_obj_tag(x_17) == 0)
 {
 lean_object* x_18; uint8_t x_19; uint8_t x_20; lean_object* x_21; 
@@ -5460,7 +5537,7 @@ if (lean_obj_tag(x_2) == 3)
 {
 lean_object* x_3; lean_object* x_4; 
 x_3 = lean_ctor_get(x_2, 1);
-x_4 = l_Std_RBNode_find___main___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_1, x_3);
+x_4 = l_Std_RBNode_find___at_Lean_IR_ExplicitRC_getVarInfo___spec__1(x_1, x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 uint8_t x_5; 
@@ -5785,7 +5862,7 @@ return x_3;
 else
 {
 lean_object* x_6; 
-x_6 = l_Std_RBNode_findCore___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_4, x_2);
+x_6 = l_Std_RBNode_findCore___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__1(x_4, x_2);
 if (lean_obj_tag(x_6) == 0)
 {
 lean_object* x_7; uint8_t x_8; lean_object* x_9; uint8_t x_10; lean_object* x_11; 
@@ -6924,7 +7001,7 @@ x_21 = lean_ctor_get(x_19, 1);
 lean_inc(x_21);
 lean_dec(x_19);
 x_22 = l_Lean_Position_lt___closed__2;
-x_23 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_18, x_21, x_22, x_20, x_3);
+x_23 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_18, x_21, x_22, x_20, x_3);
 lean_dec(x_21);
 lean_dec(x_18);
 lean_ctor_set(x_12, 1, x_23);
@@ -6954,7 +7031,7 @@ x_32 = lean_ctor_get(x_30, 1);
 lean_inc(x_32);
 lean_dec(x_30);
 x_33 = l_Lean_Position_lt___closed__2;
-x_34 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_29, x_32, x_33, x_31, x_3);
+x_34 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_29, x_32, x_33, x_31, x_3);
 lean_dec(x_32);
 lean_dec(x_29);
 x_35 = lean_alloc_ctor(0, 2, 0);
@@ -6984,7 +7061,7 @@ x_43 = lean_ctor_get(x_41, 1);
 lean_inc(x_43);
 lean_dec(x_41);
 x_44 = l_Lean_Position_lt___closed__2;
-x_45 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_43, x_44, x_42, x_3);
+x_45 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_43, x_44, x_42, x_3);
 lean_dec(x_43);
 lean_ctor_set(x_12, 0, x_45);
 x_46 = x_12;
@@ -7008,7 +7085,7 @@ x_52 = lean_ctor_get(x_50, 1);
 lean_inc(x_52);
 lean_dec(x_50);
 x_53 = l_Lean_Position_lt___closed__2;
-x_54 = l_Std_RBNode_fold___main___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_52, x_53, x_51, x_3);
+x_54 = l_Std_RBNode_fold___at___private_Lean_Compiler_IR_RC_0__Lean_IR_ExplicitRC_addDecForAlt___spec__2(x_1, x_52, x_53, x_51, x_3);
 lean_dec(x_52);
 x_55 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_55, 0, x_54);
diff --git a/stage0/stdlib/Lean/Compiler/ImplementedByAttr.c b/stage0/stdlib/Lean/Compiler/ImplementedByAttr.c
index 1a5dd650a5..efee539d97 100644
--- a/stage0/stdlib/Lean/Compiler/ImplementedByAttr.c
+++ b/stage0/stdlib/Lean/Compiler/ImplementedByAttr.c
@@ -34,6 +34,7 @@ lean_object* lean_environment_find(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____lambda__1___closed__5;
 lean_object* l_Lean_registerParametricAttribute___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__7___closed__1;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3__match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_setImplementedBy_match__1(lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
@@ -84,7 +85,6 @@ extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__4;
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_setParam___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(lean_object*, lean_object*);
 lean_object* l_Lean_resolveGlobalConstNoOverload___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_resolveGlobalConstNoOverload___rarg___lambda__1___closed__1;
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
@@ -96,13 +96,13 @@ lean_object* l_Lean_addMessageContextPartial___at_Lean_Core_Lean_AddMessageConte
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 lean_object* l_Lean_setImplementedBy___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_Compiler_getImplementedBy___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_ParametricAttribute_getParam___at_Lean_Compiler_getImplementedBy___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_resolveGlobalName___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__3;
 lean_object* lean_get_implemented_by(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Environment_getModuleIdxFor_x3f(lean_object*, lean_object*);
@@ -111,13 +111,13 @@ lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean
 lean_object* l_Lean_PersistentEnvExtension_getState___rarg(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2;
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____closed__1;
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(lean_object*, lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_Compiler_getImplementedBy___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfo___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___main___at_Lean_resolveGlobalConst___spec__2(lean_object*);
 lean_object* l_Lean_setImplementedBy___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____closed__2;
 extern lean_object* l_Lean_ParametricAttribute_Inhabited___closed__1;
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8___boxed(lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__12(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_System_FilePath_dirName___closed__1;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
@@ -577,7 +577,7 @@ return x_50;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -591,7 +591,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -1134,7 +1134,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -1681,11 +1681,11 @@ lean_dec(x_3);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_ImplementedByAttr___hyg_3____spec__8(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -1856,7 +1856,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
diff --git a/stage0/stdlib/Lean/Compiler/InitAttr.c b/stage0/stdlib/Lean/Compiler/InitAttr.c
index 7b8bfbd260..f8f3af00a3 100644
--- a/stage0/stdlib/Lean/Compiler/InitAttr.c
+++ b/stage0/stdlib/Lean/Compiler/InitAttr.c
@@ -63,6 +63,7 @@ lean_object* l___private_Lean_Compiler_InitAttr_0__Lean_isIOUnit_match__1___rarg
 lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttr___spec__7(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_378_(lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_362_(lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_registerInitAttr___spec__8(lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Lean_throwUnknownConstant___at_Lean_registerInitAttr___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_get_init_fn_name_for(lean_object*, lean_object*);
@@ -80,7 +81,6 @@ lean_object* l_Lean_throwError___at_Lean_registerInitAttr___spec__2___rarg___box
 lean_object* l_Lean_registerInitAttr___lambda__1___closed__6;
 lean_object* l_Lean_registerInitAttr_match__2(lean_object*);
 lean_object* l___private_Lean_Compiler_InitAttr_0__Lean_getIOTypeArg_match__1___rarg___closed__1;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerInitAttr___spec__8(lean_object*, lean_object*);
 lean_object* l_Lean_throwUnknownConstant___at_Lean_registerInitAttr___spec__6(lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_378____closed__1;
@@ -91,6 +91,7 @@ lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean
 lean_object* l_Lean_registerInitAttr_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_InitAttr___hyg_378____closed__2;
 lean_object* l_Lean_registerInitAttr___closed__3;
+lean_object* l_Std_RBNode_fold___at_Lean_registerInitAttr___spec__8___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttr___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getInitFnNameForCore_x3f___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_resolveGlobalName___at_Lean_registerInitAttr___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -126,7 +127,6 @@ extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed_
 lean_object* l_List_filterAux___main___at_Lean_resolveGlobalConst___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttr_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttr___lambda__1___closed__4;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerInitAttr___spec__8___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_registerInitAttr___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_resolveGlobalConstNoOverload___rarg___lambda__1___closed__2;
 uint8_t l___private_Lean_Compiler_InitAttr_0__Lean_isIOUnit(lean_object*);
@@ -137,6 +137,7 @@ lean_object* l_Lean_isIOUnitInitFnCore___boxed(lean_object*, lean_object*, lean_
 lean_object* l_Lean_registerInitAttr___lambda__1___closed__8;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 lean_object* l_Lean_isIOUnitRegularInitFn___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttr___lambda__1___closed__2;
 lean_object* l_Lean_ParametricAttribute_getParam___at_Lean_getInitFnNameForCore_x3f___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerInitAttr___lambda__1___closed__1;
@@ -147,7 +148,6 @@ lean_object* l_Lean_regularInitAttr;
 uint8_t l_Lean_isIOUnitInitFn(lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_registerInitAttr___spec__11(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_registerInitAttr___spec__10(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Environment_getModuleIdxFor_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_registerParametricAttribute___at_Lean_registerInitAttr___spec__7___lambda__1(lean_object*);
@@ -1059,7 +1059,7 @@ return x_50;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerInitAttr___spec__8(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerInitAttr___spec__8(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -1073,7 +1073,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_registerInitAttr___spec__8(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_registerInitAttr___spec__8(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -1616,7 +1616,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_registerInitAttr___spec__8(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_registerInitAttr___spec__8(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -2512,11 +2512,11 @@ lean_dec(x_3);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerInitAttr___spec__8___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_registerInitAttr___spec__8___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_registerInitAttr___spec__8(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_registerInitAttr___spec__8(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -2793,7 +2793,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
diff --git a/stage0/stdlib/Lean/Compiler/InlineAttrs.c b/stage0/stdlib/Lean/Compiler/InlineAttrs.c
index 13db35280c..e2965b0c6d 100644
--- a/stage0/stdlib/Lean/Compiler/InlineAttrs.c
+++ b/stage0/stdlib/Lean/Compiler/InlineAttrs.c
@@ -25,7 +25,6 @@ lean_object* l_List_map___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_In
 lean_object* lean_nat_div(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_getModuleEntries___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_ofExcept___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
@@ -58,6 +57,7 @@ lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__4(lean_object*
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__8;
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__4;
 lean_object* l_Lean_Compiler_hasMacroInlineAttribute___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4___boxed(lean_object*, lean_object*);
 uint8_t lean_has_macro_inline_attribute(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_List_map___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__9(lean_object*, uint8_t, lean_object*, lean_object*);
@@ -68,7 +68,6 @@ uint8_t lean_is_eager_lambda_lifting_name(lean_object*);
 extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__3;
 lean_object* l_Lean_Compiler_inlineAttrs;
 lean_object* l_List_forM___main___at_Lean_registerEnumAttributes___spec__10(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(lean_object*, lean_object*);
 uint8_t l_Lean_Compiler_InlineAttributeKind_Lean_Compiler_InlineAttrs___instance__1;
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Array_qsortAux___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__5(lean_object*, lean_object*, lean_object*);
@@ -79,8 +78,10 @@ lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__14;
 lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__22;
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_hasInlineAttribute___boxed(lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Name_isInternal(lean_object*);
 lean_object* l_Array_binSearchAux___main___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__2(lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -89,6 +90,7 @@ lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_InlineAttributeKind_beq_match__1(lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__25;
 lean_object* l_List_map___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__1;
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__16;
 extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__6;
@@ -100,9 +102,9 @@ lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean
 lean_object* l_Array_qsortAux___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__5___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_checkIsDefinition(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2___boxed(lean_object*, lean_object*);
 uint8_t lean_has_inline_attribute(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_InlineAttributeKind_Lean_Compiler_InlineAttrs___instance__2;
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__20;
 lean_object* l_Lean_Compiler_InlineAttributeKind_Lean_Compiler_InlineAttrs___instance__2___closed__1;
 lean_object* l_Lean_Compiler_hasNoInlineAttribute___boxed(lean_object*, lean_object*);
@@ -110,13 +112,11 @@ extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed_
 extern lean_object* l_Lean_EnumAttributes_Inhabited___closed__1;
 uint8_t l___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux(lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_Compiler_setInlineAttribute___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__19;
 lean_object* l_Lean_addMessageContextPartial___at_Lean_Core_Lean_AddMessageContext___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__9___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux_match__2(lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
-uint8_t l_Lean_Name_isInternal___main(lean_object*);
 extern lean_object* l_Lean_registerEnumAttributes___rarg___closed__1;
 lean_object* l_Lean_throwError___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____closed__12;
@@ -470,7 +470,7 @@ return x_11;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -484,7 +484,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -1299,7 +1299,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -1768,11 +1768,11 @@ lean_dec(x_1);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_InlineAttrs___hyg_54____spec__4(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -1911,7 +1911,7 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Compiler_InlineAttrs_0__Lean_C
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -2045,7 +2045,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
@@ -2124,7 +2124,7 @@ x_6 = l_Lean_EnumAttributes_getValue___at___private_Lean_Compiler_InlineAttrs_0_
 if (lean_obj_tag(x_6) == 0)
 {
 uint8_t x_7; 
-x_7 = l_Lean_Name_isInternal___main(x_3);
+x_7 = l_Lean_Name_isInternal(x_3);
 if (x_7 == 0)
 {
 uint8_t x_8; 
@@ -2163,11 +2163,11 @@ return x_14;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_find___at___private_Lean_Compiler_InlineAttrs_0__Lean_Compiler_hasInlineAttrAux___spec__2(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Compiler/NeverExtractAttr.c b/stage0/stdlib/Lean/Compiler/NeverExtractAttr.c
index 290acdb2d9..9d678ecb66 100644
--- a/stage0/stdlib/Lean/Compiler/NeverExtractAttr.c
+++ b/stage0/stdlib/Lean/Compiler/NeverExtractAttr.c
@@ -16,13 +16,13 @@ extern "C" {
 lean_object* l_Lean_hasNeverExtractAttribute___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_NeverExtractAttr___hyg_3____closed__4;
 extern lean_object* l_Lean_TagAttribute_Inhabited___closed__1;
+uint8_t l_Lean_Name_isInternal(lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_NeverExtractAttr_0__Lean_hasNeverExtractAttributeAux___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_NeverExtractAttr___hyg_3_(lean_object*);
 lean_object* l_Lean_neverExtractAttr;
 lean_object* l_Lean_initFn____x40_Lean_Compiler_NeverExtractAttr___hyg_3____lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Compiler_NeverExtractAttr_0__Lean_hasNeverExtractAttributeAux_match__1___rarg(lean_object*, lean_object*);
-uint8_t l_Lean_Name_isInternal___main(lean_object*);
 lean_object* l___private_Lean_Compiler_NeverExtractAttr_0__Lean_hasNeverExtractAttributeAux_match__1(lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Compiler_NeverExtractAttr___hyg_3____closed__2;
 lean_object* l_Lean_initFn____x40_Lean_Compiler_NeverExtractAttr___hyg_3____closed__1;
@@ -126,7 +126,7 @@ x_4 = l_Lean_TagAttribute_hasTag(x_3, x_1, x_2);
 if (x_4 == 0)
 {
 uint8_t x_5; 
-x_5 = l_Lean_Name_isInternal___main(x_2);
+x_5 = l_Lean_Name_isInternal(x_2);
 if (x_5 == 0)
 {
 lean_dec(x_2);
diff --git a/stage0/stdlib/Lean/Compiler/Specialize.c b/stage0/stdlib/Lean/Compiler/Specialize.c
index a815d1d8fc..4b0f144008 100644
--- a/stage0/stdlib/Lean/Compiler/Specialize.c
+++ b/stage0/stdlib/Lean/Compiler/Specialize.c
@@ -40,7 +40,6 @@ lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_Compiler_getSpecia
 lean_object* l_Lean_Compiler_SpecState_switch_match__1(lean_object*);
 extern lean_object* l_Std_HashMap_inhabited___closed__1;
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_SpecState_specInfo___default;
 extern lean_object* l_Lean_registerInternalExceptionId___closed__2;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_registerExt___rarg(lean_object*, lean_object*);
@@ -87,6 +86,7 @@ lean_object* l_Lean_SMap_find_x3f___at_Lean_Compiler_getCachedSpecialization___s
 extern lean_object* l___private_Lean_Environment_8__persistentEnvExtensionsRef;
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____closed__9;
 lean_object* l_Lean_Compiler_specExtension___elambda__2___boxed(lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__6(lean_object*, lean_object*);
@@ -118,12 +118,14 @@ lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_PersistentHashMap_insertAux___main___rarg___closed__3;
 lean_object* l_Array_iterateMAux___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_230____spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_foldlM___at_Lean_Compiler_SpecState_addEntry___spec__21(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(lean_object*, lean_object*);
 extern lean_object* l_Lean_mkEmptyEnvironment___closed__1;
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__3(lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____closed__11;
 lean_object* l_Std_PersistentHashMap_insertAux___main___at_Lean_Compiler_SpecState_addEntry___spec__3(lean_object*, size_t, size_t, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Name_isInternal(lean_object*);
 lean_object* l_Std_mkHashMapImp___rarg(lean_object*);
 lean_object* l_Lean_Compiler_SpecState_Lean_Compiler_Specialize___instance__3;
 lean_object* l_Std_AssocList_replace___at_Lean_Compiler_SpecState_addEntry___spec__22(lean_object*, lean_object*, lean_object*);
@@ -153,15 +155,12 @@ lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_
 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);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAtAux___main___at_Lean_Compiler_getCachedSpecialization___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__2(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_moveEntries___main___at_Lean_Compiler_SpecState_addEntry___spec__20(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_SpecState_cache___default___closed__2;
 lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_Compiler_getSpecializationInfo___spec__3___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAux___main___at_Lean_Compiler_SpecState_addEntry___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__5(lean_object*, lean_object*);
@@ -195,7 +194,6 @@ uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 uint8_t l_USize_decLe(size_t, size_t);
 lean_object* l_Lean_SMap_find_x3f___at_Lean_Compiler_getSpecializationInfo___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Name_isInternal___main(lean_object*);
 lean_object* l_Std_HashMapImp_moveEntries___main___at_Lean_Compiler_SpecState_addEntry___spec__9(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__1___lambda__1(lean_object*, lean_object*);
 uint8_t l_Std_AssocList_contains___at_Lean_Compiler_SpecState_addEntry___spec__18(lean_object*, lean_object*);
@@ -212,6 +210,7 @@ extern lean_object* l_Lean_registerTagAttribute___lambda__4___closed__9;
 lean_object* lean_nat_mul(lean_object*, lean_object*);
 lean_object* l_Lean_Name_getPrefix(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_addAttribute___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2___boxed(lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_230____closed__1;
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Compiler_getSpecializationInfo___spec__5___boxed(lean_object*, lean_object*);
@@ -222,6 +221,7 @@ lean_object* l_Lean_Compiler_specExtension___elambda__1(lean_object*);
 lean_object* l_Std_mkHashMap___at_Lean_Compiler_SpecState_specInfo___default___spec__1(lean_object*);
 lean_object* lean_mk_array(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_getState___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_mkStateFromImportedEntries___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_230____spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2;
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Compiler_getCachedSpecialization___spec__6___boxed(lean_object*, lean_object*);
@@ -403,7 +403,7 @@ x_1 = l_Lean_Compiler_SpecializeAttributeKind_Lean_Compiler_Specialize___instanc
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -417,7 +417,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -1232,7 +1232,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -1544,11 +1544,11 @@ x_6 = l_Lean_registerEnumAttributes___at_Lean_Compiler_initFn____x40_Lean_Compil
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_Compiler_initFn____x40_Lean_Compiler_Specialize___hyg_48____spec__2(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -1688,7 +1688,7 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Compiler_Specialize_0__Lean_Co
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -1822,7 +1822,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
@@ -1896,7 +1896,7 @@ x_5 = l_Lean_EnumAttributes_getValue___at___private_Lean_Compiler_Specialize_0__
 if (lean_obj_tag(x_5) == 0)
 {
 uint8_t x_6; 
-x_6 = l_Lean_Name_isInternal___main(x_3);
+x_6 = l_Lean_Name_isInternal(x_3);
 if (x_6 == 0)
 {
 uint8_t x_7; 
@@ -1927,11 +1927,11 @@ return x_12;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_find___at___private_Lean_Compiler_Specialize_0__Lean_Compiler_hasSpecializeAttrAux___spec__2(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -2970,54 +2970,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__2(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__2(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__2(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__6(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__6(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__6(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__6(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
@@ -3824,54 +3830,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__13(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__13(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_Compiler_SpecState_addEntry___spec__13(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__17(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__17(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__17(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_Compiler_SpecState_addEntry___spec__17(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Data/Json/Basic.c b/stage0/stdlib/Lean/Data/Json/Basic.c
index 136a14eab5..e32846adeb 100644
--- a/stage0/stdlib/Lean/Data/Json/Basic.c
+++ b/stage0/stdlib/Lean/Data/Json/Basic.c
@@ -27,6 +27,7 @@ extern lean_object* l_Int_repr___closed__1;
 lean_object* l_Lean_Json_getObj_x3f___boxed(lean_object*);
 lean_object* l_Lean_Json_getNat_x3f(lean_object*);
 lean_object* l_Lean_JsonNumber_toString(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Json_getObjVal_x3f___spec__1(lean_object*, lean_object*);
 extern lean_object* l_Sigma_HasRepr___rarg___closed__1;
 lean_object* lean_string_utf8_prev(lean_object*, lean_object*);
 lean_object* l_Lean_JsonNumber_shiftr___boxed(lean_object*, lean_object*);
@@ -67,7 +68,9 @@ lean_object* l_Lean_Json_getNat_x3f___boxed(lean_object*);
 uint8_t l_Lean_JsonNumber_decidableEq(lean_object*, lean_object*);
 lean_object* l_String_Iterator_next(lean_object*);
 lean_object* l_Lean_JsonNumber_decEq___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_JsonNumber_jsonNumberHasRepr(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Json_getObjVal_x3f___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Substring_takeRightWhileAux___main___at_Lean_JsonNumber_toString___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 lean_object* l_Lean_JsonNumber_natToJsonNumber___closed__1;
@@ -83,11 +86,9 @@ extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_530____clos
 lean_object* l___private_Lean_Data_Json_Basic_1__countDigitsAux(lean_object*, lean_object*);
 lean_object* l_Lean_Json_getBool_x3f___boxed(lean_object*);
 lean_object* l_Lean_Json_mkObj(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Json_getObjVal_x3f___spec__1___boxed(lean_object*, lean_object*);
 lean_object* lean_nat_abs(lean_object*);
 lean_object* l_Array_get_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Json_getArr_x3f(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_JsonNumber_decEq(lean_object*, lean_object*);
 lean_object* l_Lean_Json_getNum_x3f(lean_object*);
 lean_object* l_Lean_JsonNumber_toString___closed__1;
@@ -108,7 +109,6 @@ lean_object* l_Lean_Json_getObjVal_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_JsonNumber_intToJsonNumber___closed__1;
 lean_object* l_Lean_Json_getObjVal_x3f___boxed(lean_object*, lean_object*);
 lean_object* lean_nat_to_int(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Json_getObjVal_x3f___spec__1(lean_object*, lean_object*);
 uint8_t lean_string_dec_lt(lean_object*, lean_object*);
 lean_object* l_Substring_takeRightWhileAux___main___at_Lean_JsonNumber_toString___spec__1(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_JsonNumber_decEq(lean_object* x_1, lean_object* x_2) {
@@ -617,2380 +617,2457 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_string_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_string_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_string_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_string_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_string_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_string_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_string_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_string_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_string_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_string_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_string_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_string_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_string_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_string_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_string_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_string_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -3010,13 +3087,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_Json_mkObj___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_Json_mkObj___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -3364,7 +3441,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Json_getObjVal_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Json_getObjVal_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -3414,7 +3491,7 @@ if (lean_obj_tag(x_1) == 5)
 {
 lean_object* x_3; lean_object* x_4; 
 x_3 = lean_ctor_get(x_1, 0);
-x_4 = l_Std_RBNode_find___main___at_Lean_Json_getObjVal_x3f___spec__1(x_3, x_2);
+x_4 = l_Std_RBNode_find___at_Lean_Json_getObjVal_x3f___spec__1(x_3, x_2);
 return x_4;
 }
 else
@@ -3425,11 +3502,11 @@ return x_5;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Json_getObjVal_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Json_getObjVal_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Json_getObjVal_x3f___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Json_getObjVal_x3f___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Data/Json/Printer.c b/stage0/stdlib/Lean/Data/Json/Printer.c
index 15d69f7a55..da0473dcd4 100644
--- a/stage0/stdlib/Lean/Data/Json/Printer.c
+++ b/stage0/stdlib/Lean/Data/Json/Printer.c
@@ -17,7 +17,6 @@ lean_object* lean_string_push(lean_object*, uint32_t);
 lean_object* l_Lean_Json_escape(lean_object*);
 lean_object* lean_nat_div(lean_object*, lean_object*);
 lean_object* l_Lean_Json_jsonHasFormat___closed__1;
-lean_object* l_Std_RBNode_fold___main___at_Lean_Json_compress___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Json_render___main___closed__4;
 lean_object* l_Lean_Json_render___main___lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_JsonNumber_toString(lean_object*);
@@ -29,7 +28,6 @@ lean_object* l_Lean_Json_render___main(lean_object*);
 extern lean_object* l_String_splitAux___main___closed__1;
 extern lean_object* l_String_quote___closed__1;
 extern lean_object* l_List_repr___rarg___closed__3;
-lean_object* l_Std_RBNode_fold___main___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_escape___boxed(lean_object*);
 lean_object* lean_string_utf8_byte_size(lean_object*);
 lean_object* l_Lean_Json_jsonHasFormat;
@@ -56,6 +54,7 @@ lean_object* l_Lean_Json_renderString___boxed(lean_object*);
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 uint32_t l_Nat_digitChar(lean_object*);
 lean_object* l_Lean_Format_joinSep___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_Json_compress___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Json_render___main___closed__5;
 extern lean_object* l_Lean_nullKind___closed__1;
 extern lean_object* l_Id_Monad;
@@ -80,6 +79,7 @@ lean_object* l_Array_toList___rarg(lean_object*);
 lean_object* lean_string_length(lean_object*);
 extern lean_object* l_Lean_List_format___rarg___closed__3;
 lean_object* l_Lean_Json_render___main___lambda__2___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_mod(lean_object*, lean_object*);
 extern lean_object* l_Char_quoteCore___closed__5;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
@@ -541,7 +541,7 @@ lean_inc(x_31);
 lean_dec(x_1);
 x_32 = lean_box(0);
 x_33 = l_Lean_Json_render___main___closed__3;
-x_34 = l_Std_RBNode_fold___main___rarg(x_33, x_32, x_31);
+x_34 = l_Std_RBNode_fold___rarg(x_33, x_32, x_31);
 x_35 = l_Lean_formatHasFormat;
 x_36 = l_Lean_List_format___rarg___closed__3;
 x_37 = l_Lean_Format_joinSep___main___rarg(x_35, x_34, x_36);
@@ -634,7 +634,7 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Json_compress___main___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Json_compress___main___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -653,7 +653,7 @@ lean_inc(x_5);
 x_6 = lean_ctor_get(x_2, 3);
 lean_inc(x_6);
 lean_dec(x_2);
-x_7 = l_Std_RBNode_fold___main___at_Lean_Json_compress___main___spec__2(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_Json_compress___main___spec__2(x_1, x_3);
 x_8 = l_Lean_Json_renderString(x_4);
 lean_dec(x_4);
 x_9 = l___private_Init_Util_1__mkPanicMessage___closed__2;
@@ -745,7 +745,7 @@ x_22 = lean_ctor_get(x_1, 0);
 lean_inc(x_22);
 lean_dec(x_1);
 x_23 = lean_box(0);
-x_24 = l_Std_RBNode_fold___main___at_Lean_Json_compress___main___spec__2(x_23, x_22);
+x_24 = l_Std_RBNode_fold___at_Lean_Json_compress___main___spec__2(x_23, x_22);
 x_25 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_530____closed__8;
 x_26 = l_String_intercalate(x_25, x_24);
 x_27 = l_addParenHeuristic___closed__1;
diff --git a/stage0/stdlib/Lean/Data/KVMap.c b/stage0/stdlib/Lean/Data/KVMap.c
index 91ddfe6426..7bef59e5e4 100644
--- a/stage0/stdlib/Lean/Data/KVMap.c
+++ b/stage0/stdlib/Lean/Data/KVMap.c
@@ -13,66 +13,68 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Lean_DataValue_sameCtor_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_findCore_match__1(lean_object*);
 lean_object* l_Lean_KVMap_setBool(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_bool2DataValueOld___boxed(lean_object*);
 lean_object* l_Lean_KVMap_insert(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_findCore___main___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getInt___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_findCore_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_DataValue_str_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_DataValue_beq_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_DataValue_hasToString;
-lean_object* l_Lean_KVMap_boolVal___closed__2;
-lean_object* l_Lean_KVMap_natVal___closed__1;
-lean_object* l_Lean_KVMap_stringVal___closed__1;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__1;
 extern lean_object* l_List_repr___rarg___closed__1;
-lean_object* l_List_toString___at_Lean_KVMap_HasToString___spec__1(lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__3;
 lean_object* l_Lean_KVMap_findD___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_bool2DataValue___boxed(lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
-uint8_t l_Lean_KVMap_subsetAux___main(lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_nameVal___closed__1;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__3;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__2;
 extern lean_object* l_Prod_HasRepr___rarg___closed__1;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__1;
+lean_object* l_Lean_KVMap_getName_match__1(lean_object*);
 lean_object* l_Lean_KVMap_setNat(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_size(lean_object*);
-lean_object* l_Lean_KVMap_nameVal___closed__3;
 uint8_t lean_data_value_bool(lean_object*);
-lean_object* l_Lean_KVMap_intVal___closed__1;
-lean_object* l_Lean_KVMap_findCore___main(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_setString(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_getInt_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_DataValue_getBoolEx_match__1(lean_object*);
+lean_object* l_Lean_KVMap_insertCore_match__1(lean_object*);
 lean_object* l_Lean_KVMap_get___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_DataValue_HasBeq___closed__1;
-lean_object* l_Lean_KVMap_natVal___closed__3;
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Lean_DataValue_beq_match__1(lean_object*);
 extern lean_object* l_String_splitAux___main___closed__1;
 extern lean_object* l_List_repr___rarg___closed__3;
-lean_object* l_Lean_KVMap_intVal___closed__2;
-lean_object* l_Lean_KVMap_boolVal___closed__3;
-lean_object* l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2(uint8_t, lean_object*);
-lean_object* l_Lean_KVMap_boolVal___closed__1;
-lean_object* l_Lean_KVMap_nameVal;
-lean_object* l_Lean_KVMap_stringVal___closed__3;
+lean_object* l_Lean_KVMap_getName_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_find(lean_object*, lean_object*);
-extern lean_object* l_Int_zero;
-lean_object* l_Lean_KVMap_Inhabited;
+lean_object* l_Lean_KVMap_getString_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__7;
 lean_object* lean_mk_bool_data_value(uint8_t);
-lean_object* l_Lean_KVMap_HasToString(lean_object*);
-lean_object* l_Lean_KVMap_subsetAux___main___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_subsetAux_match__1(lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__1;
 lean_object* l_Int_repr(lean_object*);
 lean_object* l_Lean_nat2DataValue(lean_object*);
+lean_object* l_Lean_KVMap_getNat_match__1___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_ULift_HasRepr___rarg___closed__2;
+lean_object* l_Lean_KVMap_insert_match__1(lean_object*);
 lean_object* l_Lean_KVMap_size___boxed(lean_object*);
 lean_object* l_Lean_string2DataValueOld(lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
+lean_object* l_Lean_DataValue_sameCtor_match__1(lean_object*);
 uint8_t l_Lean_DataValue_beq(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getBool___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_stringVal;
-lean_object* l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_insert_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_List_toString___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__1(lean_object*);
+extern lean_object* l_Int_zero___closed__1;
 lean_object* l_Lean_DataValue_getBoolEx___boxed(lean_object*);
 uint8_t l_Lean_KVMap_getBool(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_name2DataValue(lean_object*);
 lean_object* l_Lean_KVMap_eqv___boxed(lean_object*, lean_object*);
 lean_object* l_List_lengthAux___main___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_getInt_match__1(lean_object*);
 lean_object* l_Lean_KVMap_find___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_stringVal___closed__2;
-lean_object* l_Lean_KVMap_intVal___closed__3;
 lean_object* l_Lean_KVMap_getName___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getString(lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
@@ -82,50 +84,78 @@ uint8_t l_Lean_KVMap_subset(lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__2;
 lean_object* l_Lean_DataValue_beq___boxed(lean_object*, lean_object*);
 extern lean_object* l_List_reprAux___main___rarg___closed__1;
-lean_object* l_Lean_KVMap_insertCore___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_findD(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_setInt(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_KVMap_contains(lean_object*, lean_object*);
 lean_object* l_Lean_int2DataValueOld(lean_object*);
+lean_object* l_Lean_KVMap_isEmpty_match__1(lean_object*);
 lean_object* l_Lean_mkBoolDataValueEx___boxed(lean_object*);
+lean_object* l_Lean_DataValue_getBoolEx_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_contains___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getInt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_bool2DataValue(uint8_t);
-lean_object* l_Lean_KVMap_HasBeq___closed__1;
+lean_object* l_Lean_KVMap_getNat_match__1(lean_object*);
 uint8_t l_Lean_KVMap_isEmpty(lean_object*);
+lean_object* l_Lean_KVMap_subsetAux_match__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getNat(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__6;
+lean_object* l_Lean_KVMap_subset_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_insertCore_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__3___closed__1;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__1;
 lean_object* l_Lean_KVMap_setName(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_name2DataValueOld(lean_object*);
+lean_object* l_Lean_KVMap_find_match__1(lean_object*);
+lean_object* l_Lean_KVMap_subsetAux_match__2(lean_object*);
 extern lean_object* l_Bool_HasRepr___closed__1;
 lean_object* l_Lean_string2DataValue(lean_object*);
 lean_object* l_Lean_KVMap_setBool___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_subset___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_HasBeq;
+lean_object* l_Lean_KVMap_isEmpty_match__1___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_getString_match__1(lean_object*);
 lean_object* l_Lean_nat2DataValueOld(lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__2;
+lean_object* l_Lean_DataValue_str_match__1(lean_object*);
 lean_object* l_Lean_DataValue_HasBeq;
 lean_object* l_Lean_KVMap_get(lean_object*);
 lean_object* l_Lean_KVMap_empty;
 extern lean_object* l_Bool_HasRepr___closed__2;
 lean_object* lean_data_value_to_string(lean_object*);
 lean_object* l_Lean_KVMap_insertCore(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_boolVal;
+lean_object* l_Lean_KVMap_getBool_match__1(lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__3;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__8;
+lean_object* l_Lean_KVMap_subset_match__1(lean_object*);
 lean_object* l_Lean_KVMap_findCore(lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_intVal;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__4;
+lean_object* l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2(uint8_t, lean_object*);
 lean_object* l_Lean_bool2DataValueOld(uint8_t);
 lean_object* l_Lean_KVMap_findCore___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getString___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_nameVal___closed__2;
 uint8_t l_Lean_DataValue_sameCtor(lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_natVal___closed__2;
+lean_object* l_Lean_KVMap_find_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__3;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__3;
 uint8_t l_Lean_KVMap_subsetAux(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__5;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__2;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__2;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__1;
 uint8_t l_Lean_KVMap_eqv(lean_object*, lean_object*);
 extern lean_object* l_System_FilePath_dirName___closed__1;
 uint8_t l_List_isEmpty___rarg(lean_object*);
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_getBool_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__2;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__3;
 lean_object* l_Lean_int2DataValue(lean_object*);
-lean_object* l_Lean_KVMap_natVal;
+lean_object* l_Lean_KVMap_entries___default;
+lean_object* l_Lean_KVMap_subsetAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_subsetAux___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__2(lean_object*);
 lean_object* l_Lean_DataValue_sameCtor___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__1;
 lean_object* l_Lean_DataValue_hasToString___closed__1;
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getNat___boxed(lean_object*, lean_object*, lean_object*);
@@ -148,6 +178,36 @@ x_3 = lean_mk_bool_data_value(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_DataValue_getBoolEx_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 1)
+{
+uint8_t x_4; lean_object* x_5; lean_object* x_6; 
+lean_dec(x_3);
+x_4 = lean_ctor_get_uint8(x_1, 0);
+lean_dec(x_1);
+x_5 = lean_box(x_4);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+else
+{
+lean_object* x_7; 
+lean_dec(x_2);
+x_7 = lean_apply_1(x_3, x_1);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_DataValue_getBoolEx_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_DataValue_getBoolEx_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t lean_data_value_bool(lean_object* x_1) {
 _start:
 {
@@ -176,6 +236,105 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_DataValue_beq_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_dec(x_5);
+lean_dec(x_4);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_6);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_2, 0);
+lean_inc(x_8);
+lean_dec(x_2);
+x_9 = lean_apply_2(x_3, x_7, x_8);
+return x_9;
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_3);
+x_10 = lean_apply_2(x_6, x_1, x_2);
+return x_10;
+}
+}
+case 1:
+{
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 1)
+{
+uint8_t x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_dec(x_6);
+x_11 = lean_ctor_get_uint8(x_1, 0);
+lean_dec(x_1);
+x_12 = lean_ctor_get_uint8(x_2, 0);
+lean_dec(x_2);
+x_13 = lean_box(x_11);
+x_14 = lean_box(x_12);
+x_15 = lean_apply_2(x_5, x_13, x_14);
+return x_15;
+}
+else
+{
+lean_object* x_16; 
+lean_dec(x_5);
+x_16 = lean_apply_2(x_6, x_1, x_2);
+return x_16;
+}
+}
+case 3:
+{
+lean_dec(x_5);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 3)
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_6);
+x_17 = lean_ctor_get(x_1, 0);
+lean_inc(x_17);
+lean_dec(x_1);
+x_18 = lean_ctor_get(x_2, 0);
+lean_inc(x_18);
+lean_dec(x_2);
+x_19 = lean_apply_2(x_4, x_17, x_18);
+return x_19;
+}
+else
+{
+lean_object* x_20; 
+lean_dec(x_4);
+x_20 = lean_apply_2(x_6, x_1, x_2);
+return x_20;
+}
+}
+default: 
+{
+lean_object* x_21; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_21 = lean_apply_2(x_6, x_1, x_2);
+return x_21;
+}
+}
+}
+}
+lean_object* l_Lean_DataValue_beq_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_DataValue_beq_match__1___rarg), 6, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_DataValue_beq(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -270,6 +429,156 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
+lean_object* l_Lean_DataValue_sameCtor_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_8);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_ctor_get(x_2, 0);
+lean_inc(x_10);
+lean_dec(x_2);
+x_11 = lean_apply_2(x_3, x_9, x_10);
+return x_11;
+}
+else
+{
+lean_object* x_12; 
+lean_dec(x_3);
+x_12 = lean_apply_2(x_8, x_1, x_2);
+return x_12;
+}
+}
+case 1:
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 1)
+{
+uint8_t x_13; uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_dec(x_8);
+x_13 = lean_ctor_get_uint8(x_1, 0);
+lean_dec(x_1);
+x_14 = lean_ctor_get_uint8(x_2, 0);
+lean_dec(x_2);
+x_15 = lean_box(x_13);
+x_16 = lean_box(x_14);
+x_17 = lean_apply_2(x_4, x_15, x_16);
+return x_17;
+}
+else
+{
+lean_object* x_18; 
+lean_dec(x_4);
+x_18 = lean_apply_2(x_8, x_1, x_2);
+return x_18;
+}
+}
+case 2:
+{
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 2)
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+lean_dec(x_8);
+x_19 = lean_ctor_get(x_1, 0);
+lean_inc(x_19);
+lean_dec(x_1);
+x_20 = lean_ctor_get(x_2, 0);
+lean_inc(x_20);
+lean_dec(x_2);
+x_21 = lean_apply_2(x_5, x_19, x_20);
+return x_21;
+}
+else
+{
+lean_object* x_22; 
+lean_dec(x_5);
+x_22 = lean_apply_2(x_8, x_1, x_2);
+return x_22;
+}
+}
+case 3:
+{
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 3)
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_8);
+x_23 = lean_ctor_get(x_1, 0);
+lean_inc(x_23);
+lean_dec(x_1);
+x_24 = lean_ctor_get(x_2, 0);
+lean_inc(x_24);
+lean_dec(x_2);
+x_25 = lean_apply_2(x_6, x_23, x_24);
+return x_25;
+}
+else
+{
+lean_object* x_26; 
+lean_dec(x_6);
+x_26 = lean_apply_2(x_8, x_1, x_2);
+return x_26;
+}
+}
+default: 
+{
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 4)
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_8);
+x_27 = lean_ctor_get(x_1, 0);
+lean_inc(x_27);
+lean_dec(x_1);
+x_28 = lean_ctor_get(x_2, 0);
+lean_inc(x_28);
+lean_dec(x_2);
+x_29 = lean_apply_2(x_7, x_27, x_28);
+return x_29;
+}
+else
+{
+lean_object* x_30; 
+lean_dec(x_7);
+x_30 = lean_apply_2(x_8, x_1, x_2);
+return x_30;
+}
+}
+}
+}
+}
+lean_object* l_Lean_DataValue_sameCtor_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_DataValue_sameCtor_match__1___rarg), 8, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_DataValue_sameCtor(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -379,6 +688,86 @@ x_1 = l_Lean_DataValue_HasBeq___closed__1;
 return x_1;
 }
 }
+lean_object* l_Lean_DataValue_str_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_1(x_2, x_7);
+return x_8;
+}
+case 1:
+{
+uint8_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_9 = lean_ctor_get_uint8(x_1, 0);
+lean_dec(x_1);
+x_10 = lean_box(x_9);
+x_11 = lean_apply_1(x_3, x_10);
+return x_11;
+}
+case 2:
+{
+lean_object* x_12; lean_object* x_13; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+lean_dec(x_1);
+x_13 = lean_apply_1(x_4, x_12);
+return x_13;
+}
+case 3:
+{
+lean_object* x_14; lean_object* x_15; 
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+lean_dec(x_1);
+x_15 = lean_apply_1(x_5, x_14);
+return x_15;
+}
+default: 
+{
+lean_object* x_16; lean_object* x_17; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_16 = lean_ctor_get(x_1, 0);
+lean_inc(x_16);
+lean_dec(x_1);
+x_17 = lean_apply_1(x_6, x_16);
+return x_17;
+}
+}
+}
+}
+lean_object* l_Lean_DataValue_str_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_DataValue_str_match__1___rarg), 6, 0);
+return x_2;
+}
+}
 lean_object* lean_data_value_to_string(lean_object* x_1) {
 _start:
 {
@@ -567,7 +956,7 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_KVMap_Inhabited() {
+static lean_object* _init_l_Lean_KVMap_entries___default() {
 _start:
 {
 lean_object* x_1; 
@@ -575,7 +964,15 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-lean_object* l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2(uint8_t x_1, lean_object* x_2) {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_box(0);
+return x_1;
+}
+}
+lean_object* l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2(uint8_t x_1, lean_object* x_2) {
 _start:
 {
 if (x_1 == 0)
@@ -594,7 +991,7 @@ lean_inc(x_4);
 x_5 = lean_ctor_get(x_2, 1);
 lean_inc(x_5);
 lean_dec(x_2);
-x_6 = l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2(x_1, x_5);
+x_6 = l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2(x_1, x_5);
 x_7 = lean_ctor_get(x_4, 0);
 lean_inc(x_7);
 x_8 = lean_ctor_get(x_4, 1);
@@ -636,7 +1033,7 @@ x_23 = lean_ctor_get(x_2, 1);
 lean_inc(x_23);
 lean_dec(x_2);
 x_24 = 0;
-x_25 = l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2(x_24, x_23);
+x_25 = l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2(x_24, x_23);
 x_26 = lean_ctor_get(x_22, 0);
 lean_inc(x_26);
 x_27 = lean_ctor_get(x_22, 1);
@@ -661,7 +1058,7 @@ return x_38;
 }
 }
 }
-lean_object* l_List_toString___at_Lean_KVMap_HasToString___spec__1(lean_object* x_1) {
+lean_object* l_List_toString___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__1(lean_object* x_1) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -674,7 +1071,7 @@ else
 {
 uint8_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_3 = 1;
-x_4 = l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2(x_3, x_1);
+x_4 = l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2(x_3, x_1);
 x_5 = l_List_repr___rarg___closed__2;
 x_6 = lean_string_append(x_5, x_4);
 lean_dec(x_4);
@@ -684,21 +1081,21 @@ return x_8;
 }
 }
 }
-lean_object* l_Lean_KVMap_HasToString(lean_object* x_1) {
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_List_toString___at_Lean_KVMap_HasToString___spec__1(x_1);
+x_2 = l_List_toString___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__1(x_1);
 return x_2;
 }
 }
-lean_object* l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
 x_3 = lean_unbox(x_1);
 lean_dec(x_1);
-x_4 = l_List_toStringAux___main___at_Lean_KVMap_HasToString___spec__2(x_3, x_2);
+x_4 = l_List_toStringAux___main___at_Lean_KVMap_Lean_Data_KVMap___instance__2___spec__2(x_3, x_2);
 return x_4;
 }
 }
@@ -710,6 +1107,22 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
+lean_object* l_Lean_KVMap_isEmpty_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_1(x_2, x_1);
+return x_3;
+}
+}
+lean_object* l_Lean_KVMap_isEmpty_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_isEmpty_match__1___rarg), 2, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_KVMap_isEmpty(lean_object* x_1) {
 _start:
 {
@@ -746,7 +1159,44 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_KVMap_findCore___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_KVMap_findCore_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_4);
+x_5 = lean_apply_1(x_3, x_2);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_6, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+lean_dec(x_6);
+x_10 = lean_apply_4(x_4, x_8, x_9, x_7, x_2);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_KVMap_findCore_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_findCore_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_KVMap_findCore(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -779,24 +1229,6 @@ return x_10;
 }
 }
 }
-lean_object* l_Lean_KVMap_findCore___main___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Lean_KVMap_findCore___main(x_1, x_2);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
-}
-}
-lean_object* l_Lean_KVMap_findCore(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Lean_KVMap_findCore___main(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_KVMap_findCore___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -807,11 +1239,27 @@ lean_dec(x_1);
 return x_3;
 }
 }
+lean_object* l_Lean_KVMap_find_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_2(x_3, x_1, x_2);
+return x_4;
+}
+}
+lean_object* l_Lean_KVMap_find_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_find_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_KVMap_find(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_3 = l_Lean_KVMap_findCore(x_1, x_2);
 return x_3;
 }
 }
@@ -829,7 +1277,7 @@ lean_object* l_Lean_KVMap_findD(lean_object* x_1, lean_object* x_2, lean_object*
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_4 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_inc(x_3);
@@ -856,129 +1304,202 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_KVMap_insertCore___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_KVMap_insertCore_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-lean_object* x_4; lean_object* x_5; 
-x_4 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_3);
-x_5 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_5, 0, x_4);
-lean_ctor_set(x_5, 1, x_1);
-return x_5;
+lean_object* x_6; 
+lean_dec(x_5);
+x_6 = lean_apply_2(x_4, x_2, x_3);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = !lean_is_exclusive(x_1);
-if (x_6 == 0)
-{
-lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
 x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
 x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+lean_dec(x_1);
 x_9 = lean_ctor_get(x_7, 0);
 lean_inc(x_9);
-x_10 = lean_name_eq(x_9, x_2);
-if (x_10 == 0)
-{
-lean_object* x_11; 
-lean_dec(x_9);
-x_11 = l_Lean_KVMap_insertCore___main(x_8, x_2, x_3);
-lean_ctor_set(x_1, 1, x_11);
-return x_1;
-}
-else
-{
-uint8_t x_12; 
-lean_dec(x_2);
-x_12 = !lean_is_exclusive(x_7);
-if (x_12 == 0)
-{
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_7, 1);
-lean_dec(x_13);
-x_14 = lean_ctor_get(x_7, 0);
-lean_dec(x_14);
-lean_ctor_set(x_7, 1, x_3);
-return x_1;
-}
-else
-{
-lean_object* x_15; 
+x_10 = lean_ctor_get(x_7, 1);
+lean_inc(x_10);
 lean_dec(x_7);
-x_15 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_15, 0, x_9);
-lean_ctor_set(x_15, 1, x_3);
-lean_ctor_set(x_1, 0, x_15);
-return x_1;
+x_11 = lean_apply_5(x_5, x_9, x_10, x_8, x_2, x_3);
+return x_11;
 }
 }
 }
-else
+lean_object* l_Lean_KVMap_insertCore_match__1(lean_object* x_1) {
+_start:
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-lean_inc(x_17);
-lean_inc(x_16);
-lean_dec(x_1);
-x_18 = lean_ctor_get(x_16, 0);
-lean_inc(x_18);
-x_19 = lean_name_eq(x_18, x_2);
-if (x_19 == 0)
-{
-lean_object* x_20; lean_object* x_21; 
-lean_dec(x_18);
-x_20 = l_Lean_KVMap_insertCore___main(x_17, x_2, x_3);
-x_21 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_21, 0, x_16);
-lean_ctor_set(x_21, 1, x_20);
-return x_21;
-}
-else
-{
-lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-lean_dec(x_2);
-if (lean_is_exclusive(x_16)) {
- lean_ctor_release(x_16, 0);
- lean_ctor_release(x_16, 1);
- x_22 = x_16;
-} else {
- lean_dec_ref(x_16);
- x_22 = lean_box(0);
-}
-if (lean_is_scalar(x_22)) {
- x_23 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_23 = x_22;
-}
-lean_ctor_set(x_23, 0, x_18);
-lean_ctor_set(x_23, 1, x_3);
-x_24 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_24, 0, x_23);
-lean_ctor_set(x_24, 1, x_17);
-return x_24;
-}
-}
-}
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_insertCore_match__1___rarg), 5, 0);
+return x_2;
 }
 }
 lean_object* l_Lean_KVMap_insertCore(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_4; 
-x_4 = l_Lean_KVMap_insertCore___main(x_1, x_2, x_3);
-return x_4;
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_4, 0, x_2);
+lean_ctor_set(x_4, 1, x_3);
+x_5 = lean_box(0);
+x_6 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_5);
+return x_6;
+}
+else
+{
+uint8_t x_7; 
+x_7 = !lean_is_exclusive(x_1);
+if (x_7 == 0)
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_ctor_get(x_1, 0);
+x_9 = !lean_is_exclusive(x_8);
+if (x_9 == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_8, 0);
+x_12 = lean_ctor_get(x_8, 1);
+x_13 = lean_name_eq(x_11, x_2);
+if (x_13 == 0)
+{
+lean_object* x_14; 
+x_14 = l_Lean_KVMap_insertCore(x_10, x_2, x_3);
+lean_ctor_set(x_1, 1, x_14);
+return x_1;
+}
+else
+{
+lean_dec(x_12);
+lean_dec(x_2);
+lean_ctor_set(x_8, 1, x_3);
+return x_1;
+}
+}
+else
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+x_15 = lean_ctor_get(x_1, 1);
+x_16 = lean_ctor_get(x_8, 0);
+x_17 = lean_ctor_get(x_8, 1);
+lean_inc(x_17);
+lean_inc(x_16);
+lean_dec(x_8);
+x_18 = lean_name_eq(x_16, x_2);
+if (x_18 == 0)
+{
+lean_object* x_19; lean_object* x_20; 
+x_19 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_19, 0, x_16);
+lean_ctor_set(x_19, 1, x_17);
+x_20 = l_Lean_KVMap_insertCore(x_15, x_2, x_3);
+lean_ctor_set(x_1, 1, x_20);
+lean_ctor_set(x_1, 0, x_19);
+return x_1;
+}
+else
+{
+lean_object* x_21; 
+lean_dec(x_17);
+lean_dec(x_2);
+x_21 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_21, 0, x_16);
+lean_ctor_set(x_21, 1, x_3);
+lean_ctor_set(x_1, 0, x_21);
+return x_1;
+}
+}
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_22 = lean_ctor_get(x_1, 0);
+x_23 = lean_ctor_get(x_1, 1);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_dec(x_1);
+x_24 = lean_ctor_get(x_22, 0);
+lean_inc(x_24);
+x_25 = lean_ctor_get(x_22, 1);
+lean_inc(x_25);
+if (lean_is_exclusive(x_22)) {
+ lean_ctor_release(x_22, 0);
+ lean_ctor_release(x_22, 1);
+ x_26 = x_22;
+} else {
+ lean_dec_ref(x_22);
+ x_26 = lean_box(0);
+}
+x_27 = lean_name_eq(x_24, x_2);
+if (x_27 == 0)
+{
+lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+if (lean_is_scalar(x_26)) {
+ x_28 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_28 = x_26;
+}
+lean_ctor_set(x_28, 0, x_24);
+lean_ctor_set(x_28, 1, x_25);
+x_29 = l_Lean_KVMap_insertCore(x_23, x_2, x_3);
+x_30 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_30, 0, x_28);
+lean_ctor_set(x_30, 1, x_29);
+return x_30;
+}
+else
+{
+lean_object* x_31; lean_object* x_32; 
+lean_dec(x_25);
+lean_dec(x_2);
+if (lean_is_scalar(x_26)) {
+ x_31 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_31 = x_26;
+}
+lean_ctor_set(x_31, 0, x_24);
+lean_ctor_set(x_31, 1, x_3);
+x_32 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_32, 0, x_31);
+lean_ctor_set(x_32, 1, x_23);
+return x_32;
+}
+}
+}
+}
+}
+lean_object* l_Lean_KVMap_insert_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_apply_3(x_4, x_1, x_2, x_3);
+return x_5;
+}
+}
+lean_object* l_Lean_KVMap_insert_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_insert_match__1___rarg), 4, 0);
+return x_2;
 }
 }
 lean_object* l_Lean_KVMap_insert(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_KVMap_insertCore___main(x_1, x_2, x_3);
+x_4 = l_Lean_KVMap_insertCore(x_1, x_2, x_3);
 return x_4;
 }
 }
@@ -986,7 +1507,7 @@ uint8_t l_Lean_KVMap_contains(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_3 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -1013,11 +1534,56 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
+lean_object* l_Lean_KVMap_getString_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 0)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+lean_dec(x_5);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_5);
+lean_dec(x_2);
+x_8 = lean_apply_1(x_3, x_1);
+return x_8;
+}
+}
+}
+}
+lean_object* l_Lean_KVMap_getString_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_getString_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_KVMap_getString(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_4 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_inc(x_3);
@@ -1057,11 +1623,56 @@ lean_dec(x_1);
 return x_4;
 }
 }
+lean_object* l_Lean_KVMap_getNat_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 3)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+lean_dec(x_5);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_5);
+lean_dec(x_2);
+x_8 = lean_apply_1(x_3, x_1);
+return x_8;
+}
+}
+}
+}
+lean_object* l_Lean_KVMap_getNat_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_getNat_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_KVMap_getNat(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_4 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_inc(x_3);
@@ -1101,11 +1712,56 @@ lean_dec(x_1);
 return x_4;
 }
 }
+lean_object* l_Lean_KVMap_getInt_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 4)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+lean_dec(x_5);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_5);
+lean_dec(x_2);
+x_8 = lean_apply_1(x_3, x_1);
+return x_8;
+}
+}
+}
+}
+lean_object* l_Lean_KVMap_getInt_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_getInt_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_KVMap_getInt(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_4 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_inc(x_3);
@@ -1145,11 +1801,56 @@ lean_dec(x_1);
 return x_4;
 }
 }
+lean_object* l_Lean_KVMap_getBool_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 1)
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_6 = lean_ctor_get_uint8(x_5, 0);
+lean_dec(x_5);
+x_7 = lean_box(x_6);
+x_8 = lean_apply_1(x_2, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_5);
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+}
+}
+lean_object* l_Lean_KVMap_getBool_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_getBool_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_KVMap_getBool(lean_object* x_1, lean_object* x_2, uint8_t x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_4 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 return x_3;
@@ -1188,11 +1889,56 @@ x_6 = lean_box(x_5);
 return x_6;
 }
 }
+lean_object* l_Lean_KVMap_getName_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 2)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+lean_dec(x_5);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_5);
+lean_dec(x_2);
+x_8 = lean_apply_1(x_3, x_1);
+return x_8;
+}
+}
+}
+}
+lean_object* l_Lean_KVMap_getName_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_getName_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_KVMap_getName(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_KVMap_findCore___main(x_1, x_2);
+x_4 = l_Lean_KVMap_findCore(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_inc(x_3);
@@ -1238,7 +1984,7 @@ _start:
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_4, 0, x_3);
-x_5 = l_Lean_KVMap_insertCore___main(x_1, x_2, x_4);
+x_5 = l_Lean_KVMap_insertCore(x_1, x_2, x_4);
 return x_5;
 }
 }
@@ -1248,7 +1994,7 @@ _start:
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_alloc_ctor(3, 1, 0);
 lean_ctor_set(x_4, 0, x_3);
-x_5 = l_Lean_KVMap_insertCore___main(x_1, x_2, x_4);
+x_5 = l_Lean_KVMap_insertCore(x_1, x_2, x_4);
 return x_5;
 }
 }
@@ -1258,7 +2004,7 @@ _start:
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_alloc_ctor(4, 1, 0);
 lean_ctor_set(x_4, 0, x_3);
-x_5 = l_Lean_KVMap_insertCore___main(x_1, x_2, x_4);
+x_5 = l_Lean_KVMap_insertCore(x_1, x_2, x_4);
 return x_5;
 }
 }
@@ -1268,7 +2014,7 @@ _start:
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_alloc_ctor(1, 0, 1);
 lean_ctor_set_uint8(x_4, 0, x_3);
-x_5 = l_Lean_KVMap_insertCore___main(x_1, x_2, x_4);
+x_5 = l_Lean_KVMap_insertCore(x_1, x_2, x_4);
 return x_5;
 }
 }
@@ -1288,11 +2034,79 @@ _start:
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_4, 0, x_3);
-x_5 = l_Lean_KVMap_insertCore___main(x_1, x_2, x_4);
+x_5 = l_Lean_KVMap_insertCore(x_1, x_2, x_4);
 return x_5;
 }
 }
-uint8_t l_Lean_KVMap_subsetAux___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_KVMap_subsetAux_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_KVMap_subsetAux_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_subsetAux_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_KVMap_subsetAux_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_4);
+x_5 = lean_apply_1(x_3, x_2);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_6, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+lean_dec(x_6);
+x_10 = lean_apply_4(x_4, x_8, x_9, x_7, x_2);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_KVMap_subsetAux_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_subsetAux_match__2___rarg), 4, 0);
+return x_2;
+}
+}
+uint8_t l_Lean_KVMap_subsetAux(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -1308,7 +2122,7 @@ x_4 = lean_ctor_get(x_1, 0);
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = lean_ctor_get(x_4, 0);
 x_7 = lean_ctor_get(x_4, 1);
-x_8 = l_Lean_KVMap_findCore___main(x_2, x_6);
+x_8 = l_Lean_KVMap_findCore(x_2, x_6);
 if (lean_obj_tag(x_8) == 0)
 {
 uint8_t x_9; 
@@ -1338,25 +2152,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Lean_KVMap_subsetAux___main___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l_Lean_KVMap_subsetAux___main(x_1, x_2);
-lean_dec(x_2);
-lean_dec(x_1);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-uint8_t l_Lean_KVMap_subsetAux(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = l_Lean_KVMap_subsetAux___main(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_KVMap_subsetAux___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1368,11 +2163,27 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
+lean_object* l_Lean_KVMap_subset_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_2(x_3, x_1, x_2);
+return x_4;
+}
+}
+lean_object* l_Lean_KVMap_subset_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_subset_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_KVMap_subset(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
-x_3 = l_Lean_KVMap_subsetAux___main(x_1, x_2);
+x_3 = l_Lean_KVMap_subsetAux(x_1, x_2);
 return x_3;
 }
 }
@@ -1391,7 +2202,7 @@ uint8_t l_Lean_KVMap_eqv(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
-x_3 = l_Lean_KVMap_subsetAux___main(x_1, x_2);
+x_3 = l_Lean_KVMap_subsetAux(x_1, x_2);
 if (x_3 == 0)
 {
 uint8_t x_4; 
@@ -1401,7 +2212,7 @@ return x_4;
 else
 {
 uint8_t x_5; 
-x_5 = l_Lean_KVMap_subsetAux___main(x_2, x_1);
+x_5 = l_Lean_KVMap_subsetAux(x_2, x_1);
 return x_5;
 }
 }
@@ -1417,7 +2228,7 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_KVMap_HasBeq___closed__1() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__3___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1425,11 +2236,11 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_eqv___boxed), 2, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_HasBeq() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_KVMap_HasBeq___closed__1;
+x_1 = l_Lean_KVMap_Lean_Data_KVMap___instance__3___closed__1;
 return x_1;
 }
 }
@@ -1452,7 +2263,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_KVMap_get___rarg), 4, 0);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_KVMap_boolVal___closed__1() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1460,7 +2271,7 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_setBool___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_boolVal___closed__2() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -1468,13 +2279,13 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_getBool___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_boolVal___closed__3() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__3() {
 _start:
 {
 uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_1 = 0;
-x_2 = l_Lean_KVMap_boolVal___closed__1;
-x_3 = l_Lean_KVMap_boolVal___closed__2;
+x_2 = l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__1;
+x_3 = l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__2;
 x_4 = lean_box(x_1);
 x_5 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_5, 0, x_4);
@@ -1483,15 +2294,15 @@ lean_ctor_set(x_5, 2, x_3);
 return x_5;
 }
 }
-static lean_object* _init_l_Lean_KVMap_boolVal() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_KVMap_boolVal___closed__3;
+x_1 = l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__3;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_natVal___closed__1() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1499,7 +2310,7 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_setNat), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_natVal___closed__2() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -1507,13 +2318,13 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_getNat___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_natVal___closed__3() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = lean_unsigned_to_nat(0u);
-x_2 = l_Lean_KVMap_natVal___closed__1;
-x_3 = l_Lean_KVMap_natVal___closed__2;
+x_2 = l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__1;
+x_3 = l_Lean_KVMap_Lean_Data_KVMap___instance__5___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);
@@ -1521,15 +2332,15 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_KVMap_natVal() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_KVMap_natVal___closed__3;
+x_1 = l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__3;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_intVal___closed__1() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1537,7 +2348,7 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_setInt), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_intVal___closed__2() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -1545,13 +2356,13 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_getInt___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_intVal___closed__3() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Int_zero;
-x_2 = l_Lean_KVMap_intVal___closed__1;
-x_3 = l_Lean_KVMap_intVal___closed__2;
+x_1 = l_Int_zero___closed__1;
+x_2 = l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__1;
+x_3 = l_Lean_KVMap_Lean_Data_KVMap___instance__6___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);
@@ -1559,15 +2370,15 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_KVMap_intVal() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_KVMap_intVal___closed__3;
+x_1 = l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__3;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_nameVal___closed__1() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1575,7 +2386,7 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_setName), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_nameVal___closed__2() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -1583,13 +2394,13 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_getName___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_nameVal___closed__3() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = lean_box(0);
-x_2 = l_Lean_KVMap_nameVal___closed__1;
-x_3 = l_Lean_KVMap_nameVal___closed__2;
+x_2 = l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__1;
+x_3 = l_Lean_KVMap_Lean_Data_KVMap___instance__7___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);
@@ -1597,15 +2408,15 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_KVMap_nameVal() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_KVMap_nameVal___closed__3;
+x_1 = l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__3;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_stringVal___closed__1() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1613,7 +2424,7 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_setString), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_stringVal___closed__2() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -1621,13 +2432,13 @@ x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_getString___boxed), 3, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_KVMap_stringVal___closed__3() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = l_String_splitAux___main___closed__1;
-x_2 = l_Lean_KVMap_stringVal___closed__1;
-x_3 = l_Lean_KVMap_stringVal___closed__2;
+x_2 = l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__1;
+x_3 = l_Lean_KVMap_Lean_Data_KVMap___instance__8___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);
@@ -1635,11 +2446,11 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_KVMap_stringVal() {
+static lean_object* _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_KVMap_stringVal___closed__3;
+x_1 = l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__3;
 return x_1;
 }
 }
@@ -1664,54 +2475,56 @@ l_Lean_DataValue_hasToString___closed__1 = _init_l_Lean_DataValue_hasToString___
 lean_mark_persistent(l_Lean_DataValue_hasToString___closed__1);
 l_Lean_DataValue_hasToString = _init_l_Lean_DataValue_hasToString();
 lean_mark_persistent(l_Lean_DataValue_hasToString);
-l_Lean_KVMap_Inhabited = _init_l_Lean_KVMap_Inhabited();
-lean_mark_persistent(l_Lean_KVMap_Inhabited);
+l_Lean_KVMap_entries___default = _init_l_Lean_KVMap_entries___default();
+lean_mark_persistent(l_Lean_KVMap_entries___default);
+l_Lean_KVMap_Lean_Data_KVMap___instance__1 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__1();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__1);
 l_Lean_KVMap_empty = _init_l_Lean_KVMap_empty();
 lean_mark_persistent(l_Lean_KVMap_empty);
-l_Lean_KVMap_HasBeq___closed__1 = _init_l_Lean_KVMap_HasBeq___closed__1();
-lean_mark_persistent(l_Lean_KVMap_HasBeq___closed__1);
-l_Lean_KVMap_HasBeq = _init_l_Lean_KVMap_HasBeq();
-lean_mark_persistent(l_Lean_KVMap_HasBeq);
-l_Lean_KVMap_boolVal___closed__1 = _init_l_Lean_KVMap_boolVal___closed__1();
-lean_mark_persistent(l_Lean_KVMap_boolVal___closed__1);
-l_Lean_KVMap_boolVal___closed__2 = _init_l_Lean_KVMap_boolVal___closed__2();
-lean_mark_persistent(l_Lean_KVMap_boolVal___closed__2);
-l_Lean_KVMap_boolVal___closed__3 = _init_l_Lean_KVMap_boolVal___closed__3();
-lean_mark_persistent(l_Lean_KVMap_boolVal___closed__3);
-l_Lean_KVMap_boolVal = _init_l_Lean_KVMap_boolVal();
-lean_mark_persistent(l_Lean_KVMap_boolVal);
-l_Lean_KVMap_natVal___closed__1 = _init_l_Lean_KVMap_natVal___closed__1();
-lean_mark_persistent(l_Lean_KVMap_natVal___closed__1);
-l_Lean_KVMap_natVal___closed__2 = _init_l_Lean_KVMap_natVal___closed__2();
-lean_mark_persistent(l_Lean_KVMap_natVal___closed__2);
-l_Lean_KVMap_natVal___closed__3 = _init_l_Lean_KVMap_natVal___closed__3();
-lean_mark_persistent(l_Lean_KVMap_natVal___closed__3);
-l_Lean_KVMap_natVal = _init_l_Lean_KVMap_natVal();
-lean_mark_persistent(l_Lean_KVMap_natVal);
-l_Lean_KVMap_intVal___closed__1 = _init_l_Lean_KVMap_intVal___closed__1();
-lean_mark_persistent(l_Lean_KVMap_intVal___closed__1);
-l_Lean_KVMap_intVal___closed__2 = _init_l_Lean_KVMap_intVal___closed__2();
-lean_mark_persistent(l_Lean_KVMap_intVal___closed__2);
-l_Lean_KVMap_intVal___closed__3 = _init_l_Lean_KVMap_intVal___closed__3();
-lean_mark_persistent(l_Lean_KVMap_intVal___closed__3);
-l_Lean_KVMap_intVal = _init_l_Lean_KVMap_intVal();
-lean_mark_persistent(l_Lean_KVMap_intVal);
-l_Lean_KVMap_nameVal___closed__1 = _init_l_Lean_KVMap_nameVal___closed__1();
-lean_mark_persistent(l_Lean_KVMap_nameVal___closed__1);
-l_Lean_KVMap_nameVal___closed__2 = _init_l_Lean_KVMap_nameVal___closed__2();
-lean_mark_persistent(l_Lean_KVMap_nameVal___closed__2);
-l_Lean_KVMap_nameVal___closed__3 = _init_l_Lean_KVMap_nameVal___closed__3();
-lean_mark_persistent(l_Lean_KVMap_nameVal___closed__3);
-l_Lean_KVMap_nameVal = _init_l_Lean_KVMap_nameVal();
-lean_mark_persistent(l_Lean_KVMap_nameVal);
-l_Lean_KVMap_stringVal___closed__1 = _init_l_Lean_KVMap_stringVal___closed__1();
-lean_mark_persistent(l_Lean_KVMap_stringVal___closed__1);
-l_Lean_KVMap_stringVal___closed__2 = _init_l_Lean_KVMap_stringVal___closed__2();
-lean_mark_persistent(l_Lean_KVMap_stringVal___closed__2);
-l_Lean_KVMap_stringVal___closed__3 = _init_l_Lean_KVMap_stringVal___closed__3();
-lean_mark_persistent(l_Lean_KVMap_stringVal___closed__3);
-l_Lean_KVMap_stringVal = _init_l_Lean_KVMap_stringVal();
-lean_mark_persistent(l_Lean_KVMap_stringVal);
+l_Lean_KVMap_Lean_Data_KVMap___instance__3___closed__1 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__3___closed__1();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__3___closed__1);
+l_Lean_KVMap_Lean_Data_KVMap___instance__3 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__3();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__3);
+l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__1 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__1();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__1);
+l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__2 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__2();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__2);
+l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__3 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__3();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__4___closed__3);
+l_Lean_KVMap_Lean_Data_KVMap___instance__4 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__4();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__4);
+l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__1 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__1();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__1);
+l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__2 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__2();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__2);
+l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__3 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__3();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__5___closed__3);
+l_Lean_KVMap_Lean_Data_KVMap___instance__5 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__5();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__5);
+l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__1 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__1();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__1);
+l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__2 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__2();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__2);
+l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__3 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__3();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__6___closed__3);
+l_Lean_KVMap_Lean_Data_KVMap___instance__6 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__6();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__6);
+l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__1 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__1();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__1);
+l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__2 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__2();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__2);
+l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__3 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__3();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__7___closed__3);
+l_Lean_KVMap_Lean_Data_KVMap___instance__7 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__7();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__7);
+l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__1 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__1();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__1);
+l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__2 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__2();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__2);
+l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__3 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__3();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__8___closed__3);
+l_Lean_KVMap_Lean_Data_KVMap___instance__8 = _init_l_Lean_KVMap_Lean_Data_KVMap___instance__8();
+lean_mark_persistent(l_Lean_KVMap_Lean_Data_KVMap___instance__8);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Data/LBool.c b/stage0/stdlib/Lean/Data/LBool.c
index 8abdf15c1f..9388d3e9c2 100644
--- a/stage0/stdlib/Lean/Data/LBool.c
+++ b/stage0/stdlib/Lean/Data/LBool.c
@@ -13,29 +13,44 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-uint8_t l_Lean_LBool_Inhabited;
-lean_object* l_Lean_LBool_HasToString;
+lean_object* l_Lean_LBool_neg_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_LBool_Lean_Data_LBool___instance__3;
 lean_object* l_Lean_LBool_toString(uint8_t);
 lean_object* l_toLBoolM___rarg___lambda__1(lean_object*, uint8_t);
-lean_object* l_Lean_LBool_HasBeq;
-lean_object* l_Lean_LBool_HasBeq___closed__1;
+uint8_t l_Lean_LBool_Lean_Data_LBool___instance__1;
+lean_object* l_Lean_LBool_Lean_Data_LBool___instance__2___closed__1;
 lean_object* l_Lean_LBool_toString___boxed(lean_object*);
+lean_object* l_Bool_toLBool_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_toLBoolM(lean_object*);
+lean_object* l_Bool_toLBool_match__1___rarg(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_LBool_neg_match__1(lean_object*);
+lean_object* l_Lean_LBool_neg_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_LBool_beq_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_LBool_and(uint8_t, uint8_t);
+lean_object* l_Lean_LBool_and_match__1(lean_object*);
 lean_object* l_Lean_LBool_neg___boxed(lean_object*);
 lean_object* l_Bool_toLBool___boxed(lean_object*);
 lean_object* l_Lean_LBool_and___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_LBool_and_match__1___rarg(uint8_t, uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_LBool_beq_match__1(lean_object*);
 extern lean_object* l_Bool_HasRepr___closed__1;
+lean_object* l_Lean_LBool_toString_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_toLBoolM___rarg___lambda__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Bool_HasRepr___closed__2;
+lean_object* l_Bool_toLBool_match__1(lean_object*);
+lean_object* l_Lean_LBool_Lean_Data_LBool___instance__2;
 uint8_t l_Lean_LBool_neg(uint8_t);
 uint8_t l_Bool_toLBool(uint8_t);
 lean_object* l_Lean_LBool_toString___closed__1;
 uint8_t l_Lean_LBool_beq(uint8_t, uint8_t);
+lean_object* l_Lean_LBool_toString_match__1(lean_object*);
+lean_object* l_Lean_LBool_and_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LBool_beq___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_LBool_HasToString___closed__1;
+lean_object* l_Lean_LBool_Lean_Data_LBool___instance__3___closed__1;
 lean_object* l_toLBoolM___rarg(lean_object*, lean_object*);
-static uint8_t _init_l_Lean_LBool_Inhabited() {
+lean_object* l_Lean_LBool_toString_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_LBool_beq_match__1___rarg(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+static uint8_t _init_l_Lean_LBool_Lean_Data_LBool___instance__1() {
 _start:
 {
 uint8_t x_1; 
@@ -43,6 +58,58 @@ x_1 = 0;
 return x_1;
 }
 }
+lean_object* l_Lean_LBool_neg_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_2);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_3, x_5);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_7 = lean_box(0);
+x_8 = lean_apply_1(x_2, 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_Lean_LBool_neg_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_LBool_neg_match__1___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_LBool_neg_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_Lean_LBool_neg_match__1___rarg(x_5, x_2, x_3, x_4);
+return x_6;
+}
+}
 uint8_t l_Lean_LBool_neg(uint8_t x_1) {
 _start:
 {
@@ -61,7 +128,9 @@ return x_3;
 }
 default: 
 {
-return x_1;
+uint8_t x_4; 
+x_4 = 2;
+return x_4;
 }
 }
 }
@@ -77,6 +146,51 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
+lean_object* l_Lean_LBool_and_match__1___rarg(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_box(x_1);
+if (lean_obj_tag(x_5) == 1)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_4);
+x_6 = lean_box(x_2);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_5);
+lean_dec(x_3);
+x_8 = lean_box(x_1);
+x_9 = lean_box(x_2);
+x_10 = lean_apply_2(x_4, x_8, x_9);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_LBool_and_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_LBool_and_match__1___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_LBool_and_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; uint8_t x_6; lean_object* x_7; 
+x_5 = lean_unbox(x_1);
+lean_dec(x_1);
+x_6 = lean_unbox(x_2);
+lean_dec(x_2);
+x_7 = l_Lean_LBool_and_match__1___rarg(x_5, x_6, x_3, x_4);
+return x_7;
+}
+}
 uint8_t l_Lean_LBool_and(uint8_t x_1, uint8_t x_2) {
 _start:
 {
@@ -106,6 +220,108 @@ x_6 = lean_box(x_5);
 return x_6;
 }
 }
+lean_object* l_Lean_LBool_beq_match__1___rarg(uint8_t x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+switch (x_1) {
+case 0:
+{
+lean_object* x_7; 
+lean_dec(x_5);
+lean_dec(x_3);
+x_7 = lean_box(x_2);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; 
+lean_dec(x_6);
+x_8 = lean_box(0);
+x_9 = lean_apply_1(x_4, x_8);
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_7);
+lean_dec(x_4);
+x_10 = lean_box(x_1);
+x_11 = lean_box(x_2);
+x_12 = lean_apply_2(x_6, x_10, x_11);
+return x_12;
+}
+}
+case 1:
+{
+lean_object* x_13; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_13 = lean_box(x_2);
+if (lean_obj_tag(x_13) == 1)
+{
+lean_object* x_14; lean_object* x_15; 
+lean_dec(x_6);
+x_14 = lean_box(0);
+x_15 = lean_apply_1(x_3, x_14);
+return x_15;
+}
+else
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_dec(x_13);
+lean_dec(x_3);
+x_16 = lean_box(x_1);
+x_17 = lean_box(x_2);
+x_18 = lean_apply_2(x_6, x_16, x_17);
+return x_18;
+}
+}
+default: 
+{
+lean_object* x_19; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_19 = lean_box(x_2);
+if (lean_obj_tag(x_19) == 2)
+{
+lean_object* x_20; lean_object* x_21; 
+lean_dec(x_6);
+x_20 = lean_box(0);
+x_21 = lean_apply_1(x_5, x_20);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_19);
+lean_dec(x_5);
+x_22 = lean_box(x_1);
+x_23 = lean_box(x_2);
+x_24 = lean_apply_2(x_6, x_22, x_23);
+return x_24;
+}
+}
+}
+}
+}
+lean_object* l_Lean_LBool_beq_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_LBool_beq_match__1___rarg___boxed), 6, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_LBool_beq_match__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+uint8_t x_7; uint8_t x_8; lean_object* x_9; 
+x_7 = lean_unbox(x_1);
+lean_dec(x_1);
+x_8 = lean_unbox(x_2);
+lean_dec(x_2);
+x_9 = l_Lean_LBool_beq_match__1___rarg(x_7, x_8, x_3, x_4, x_5, x_6);
+return x_9;
+}
+}
 uint8_t l_Lean_LBool_beq(uint8_t x_1, uint8_t x_2) {
 _start:
 {
@@ -180,7 +396,7 @@ x_6 = lean_box(x_5);
 return x_6;
 }
 }
-static lean_object* _init_l_Lean_LBool_HasBeq___closed__1() {
+static lean_object* _init_l_Lean_LBool_Lean_Data_LBool___instance__2___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -188,14 +404,66 @@ x_1 = lean_alloc_closure((void*)(l_Lean_LBool_beq___boxed), 2, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_LBool_HasBeq() {
+static lean_object* _init_l_Lean_LBool_Lean_Data_LBool___instance__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_LBool_HasBeq___closed__1;
+x_1 = l_Lean_LBool_Lean_Data_LBool___instance__2___closed__1;
 return x_1;
 }
 }
+lean_object* l_Lean_LBool_toString_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_2);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_3, x_5);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_7 = lean_box(0);
+x_8 = lean_apply_1(x_2, 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_Lean_LBool_toString_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_LBool_toString_match__1___rarg___boxed), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_LBool_toString_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_Lean_LBool_toString_match__1___rarg(x_5, x_2, x_3, x_4);
+return x_6;
+}
+}
 static lean_object* _init_l_Lean_LBool_toString___closed__1() {
 _start:
 {
@@ -239,7 +507,7 @@ x_3 = l_Lean_LBool_toString(x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_LBool_HasToString___closed__1() {
+static lean_object* _init_l_Lean_LBool_Lean_Data_LBool___instance__3___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -247,14 +515,53 @@ x_1 = lean_alloc_closure((void*)(l_Lean_LBool_toString___boxed), 1, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_LBool_HasToString() {
+static lean_object* _init_l_Lean_LBool_Lean_Data_LBool___instance__3() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_LBool_HasToString___closed__1;
+x_1 = l_Lean_LBool_Lean_Data_LBool___instance__3___closed__1;
 return x_1;
 }
 }
+lean_object* l_Bool_toLBool_match__1___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (x_1 == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Bool_toLBool_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Bool_toLBool_match__1___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Bool_toLBool_match__1___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 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_Bool_toLBool_match__1___rarg(x_4, x_2, x_3);
+return x_5;
+}
+}
 uint8_t l_Bool_toLBool(uint8_t x_1) {
 _start:
 {
@@ -338,17 +645,17 @@ _G_initialized = true;
 res = initialize_Init(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_LBool_Inhabited = _init_l_Lean_LBool_Inhabited();
-l_Lean_LBool_HasBeq___closed__1 = _init_l_Lean_LBool_HasBeq___closed__1();
-lean_mark_persistent(l_Lean_LBool_HasBeq___closed__1);
-l_Lean_LBool_HasBeq = _init_l_Lean_LBool_HasBeq();
-lean_mark_persistent(l_Lean_LBool_HasBeq);
+l_Lean_LBool_Lean_Data_LBool___instance__1 = _init_l_Lean_LBool_Lean_Data_LBool___instance__1();
+l_Lean_LBool_Lean_Data_LBool___instance__2___closed__1 = _init_l_Lean_LBool_Lean_Data_LBool___instance__2___closed__1();
+lean_mark_persistent(l_Lean_LBool_Lean_Data_LBool___instance__2___closed__1);
+l_Lean_LBool_Lean_Data_LBool___instance__2 = _init_l_Lean_LBool_Lean_Data_LBool___instance__2();
+lean_mark_persistent(l_Lean_LBool_Lean_Data_LBool___instance__2);
 l_Lean_LBool_toString___closed__1 = _init_l_Lean_LBool_toString___closed__1();
 lean_mark_persistent(l_Lean_LBool_toString___closed__1);
-l_Lean_LBool_HasToString___closed__1 = _init_l_Lean_LBool_HasToString___closed__1();
-lean_mark_persistent(l_Lean_LBool_HasToString___closed__1);
-l_Lean_LBool_HasToString = _init_l_Lean_LBool_HasToString();
-lean_mark_persistent(l_Lean_LBool_HasToString);
+l_Lean_LBool_Lean_Data_LBool___instance__3___closed__1 = _init_l_Lean_LBool_Lean_Data_LBool___instance__3___closed__1();
+lean_mark_persistent(l_Lean_LBool_Lean_Data_LBool___instance__3___closed__1);
+l_Lean_LBool_Lean_Data_LBool___instance__3 = _init_l_Lean_LBool_Lean_Data_LBool___instance__3();
+lean_mark_persistent(l_Lean_LBool_Lean_Data_LBool___instance__3);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Data/LOption.c b/stage0/stdlib/Lean/Data/LOption.c
index 1a387ccd71..94c12fc680 100644
--- a/stage0/stdlib/Lean/Data/LOption.c
+++ b/stage0/stdlib/Lean/Data/LOption.c
@@ -13,26 +13,32 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Lean_LOption_beq_match__1(lean_object*, lean_object*);
 extern lean_object* l_Option_HasRepr___rarg___closed__2;
 lean_object* l_toLOptionM___rarg___lambda__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_LOption_beq_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Option_toLOption___rarg(lean_object*);
 lean_object* l_toLOptionM(lean_object*, lean_object*);
 extern lean_object* l_Option_HasRepr___rarg___closed__1;
-lean_object* l_Lean_LOption_HasBeq(lean_object*);
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2_match__1(lean_object*, lean_object*);
 lean_object* l_Lean_LOption_beq___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
-lean_object* l_Lean_LOption_HasToString___rarg___closed__1;
 lean_object* l_Lean_LOption_beq(lean_object*);
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2(lean_object*);
 extern lean_object* l_ULift_HasRepr___rarg___closed__2;
-lean_object* l_Lean_LOption_HasToString___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_LOption_HasToString(lean_object*);
-lean_object* l_Lean_LOption_Inhabited(lean_object*);
-lean_object* l_Lean_LOption_HasBeq___rarg(lean_object*);
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__1(lean_object*);
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__3___rarg(lean_object*);
 lean_object* l_Option_toLOption___rarg___boxed(lean_object*);
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__3(lean_object*);
 lean_object* l_Option_toLOption(lean_object*);
+lean_object* l_Option_toLOption_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_toLOptionM___rarg(lean_object*, lean_object*);
 lean_object* l_toLOptionM___rarg___lambda__1(lean_object*, lean_object*);
-lean_object* l_Lean_LOption_Inhabited(lean_object* x_1) {
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Option_toLOption_match__1(lean_object*, lean_object*);
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2___rarg___closed__1;
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -40,7 +46,51 @@ x_2 = lean_box(0);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_LOption_HasToString___rarg___closed__1() {
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_1(x_4, x_7);
+return x_8;
+}
+default: 
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_9 = lean_box(0);
+x_10 = lean_apply_1(x_3, x_9);
+return x_10;
+}
+}
+}
+}
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_LOption_Lean_Data_LOption___instance__2_match__1___rarg), 4, 0);
+return x_3;
+}
+}
+static lean_object* _init_l_Lean_LOption_Lean_Data_LOption___instance__2___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -48,7 +98,7 @@ x_1 = lean_mk_string("undef");
 return x_1;
 }
 }
-lean_object* l_Lean_LOption_HasToString___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 switch (lean_obj_tag(x_2)) {
@@ -77,20 +127,100 @@ default:
 {
 lean_object* x_10; 
 lean_dec(x_1);
-x_10 = l_Lean_LOption_HasToString___rarg___closed__1;
+x_10 = l_Lean_LOption_Lean_Data_LOption___instance__2___rarg___closed__1;
 return x_10;
 }
 }
 }
 }
-lean_object* l_Lean_LOption_HasToString(lean_object* x_1) {
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_LOption_HasToString___rarg), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_LOption_Lean_Data_LOption___instance__2___rarg), 2, 0);
 return x_2;
 }
 }
+lean_object* l_Lean_LOption_beq_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_dec(x_5);
+lean_dec(x_4);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_6);
+x_7 = lean_box(0);
+x_8 = lean_apply_1(x_3, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_3);
+x_9 = lean_apply_2(x_6, x_1, x_2);
+return x_9;
+}
+}
+case 1:
+{
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 1)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_6);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_ctor_get(x_2, 0);
+lean_inc(x_11);
+lean_dec(x_2);
+x_12 = lean_apply_2(x_5, x_10, x_11);
+return x_12;
+}
+else
+{
+lean_object* x_13; 
+lean_dec(x_5);
+x_13 = lean_apply_2(x_6, x_1, x_2);
+return x_13;
+}
+}
+default: 
+{
+lean_dec(x_5);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 2)
+{
+lean_object* x_14; lean_object* x_15; 
+lean_dec(x_6);
+x_14 = lean_box(0);
+x_15 = lean_apply_1(x_4, x_14);
+return x_15;
+}
+else
+{
+lean_object* x_16; 
+lean_dec(x_4);
+x_16 = lean_apply_2(x_6, x_1, x_2);
+return x_16;
+}
+}
+}
+}
+}
+lean_object* l_Lean_LOption_beq_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_LOption_beq_match__1___rarg), 6, 0);
+return x_3;
+}
+}
 lean_object* l_Lean_LOption_beq___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -169,7 +299,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_LOption_beq___rarg), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Lean_LOption_HasBeq___rarg(lean_object* x_1) {
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__3___rarg(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -178,14 +308,45 @@ lean_closure_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_LOption_HasBeq(lean_object* x_1) {
+lean_object* l_Lean_LOption_Lean_Data_LOption___instance__3(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_LOption_HasBeq___rarg), 1, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_LOption_Lean_Data_LOption___instance__3___rarg), 1, 0);
 return x_2;
 }
 }
+lean_object* l_Option_toLOption_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Option_toLOption_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Option_toLOption_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 lean_object* l_Option_toLOption___rarg(lean_object* x_1) {
 _start:
 {
@@ -276,8 +437,8 @@ _G_initialized = true;
 res = initialize_Init(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_LOption_HasToString___rarg___closed__1 = _init_l_Lean_LOption_HasToString___rarg___closed__1();
-lean_mark_persistent(l_Lean_LOption_HasToString___rarg___closed__1);
+l_Lean_LOption_Lean_Data_LOption___instance__2___rarg___closed__1 = _init_l_Lean_LOption_Lean_Data_LOption___instance__2___rarg___closed__1();
+lean_mark_persistent(l_Lean_LOption_Lean_Data_LOption___instance__2___rarg___closed__1);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Data/Lsp/InitShutdown.c b/stage0/stdlib/Lean/Data/Lsp/InitShutdown.c
index efd3315927..eae70144e1 100644
--- a/stage0/stdlib/Lean/Data/Lsp/InitShutdown.c
+++ b/stage0/stdlib/Lean/Data/Lsp/InitShutdown.c
@@ -16,6 +16,7 @@ extern "C" {
 lean_object* l_Lean_Lsp_Trace_hasFromJson___boxed(lean_object*);
 lean_object* l_Lean_Lsp_Trace_hasFromJson___closed__1;
 lean_object* l_Lean_Lsp_ServerInfo_hasToJson___boxed(lean_object*);
+extern lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1;
 lean_object* l_Lean_Lsp_ClientInfo_hasFromJson___boxed(lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_Location_hasFromJson___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_ClientInfo_hasFromJson(lean_object*);
@@ -47,7 +48,6 @@ lean_object* l_Lean_Json_opt___at_Lean_Lsp_InitializeResult_hasToJson___spec__1(
 lean_object* l_Lean_Lsp_InitializeParams_hasFromJson___closed__5;
 lean_object* l_Lean_Lsp_InitializeParams_hasFromJson___closed__7;
 lean_object* l_Lean_Lsp_Trace_hasFromJson___closed__5;
-extern lean_object* l_Lean_verboseOption___closed__1;
 lean_object* l_Lean_Lsp_Trace_hasFromJson___closed__3;
 lean_object* l_Lean_Json_mkObj(lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_InitializeParams_hasFromJson___spec__5(lean_object*, lean_object*);
@@ -206,7 +206,7 @@ x_8 = lean_string_dec_eq(x_4, x_7);
 if (x_8 == 0)
 {
 lean_object* x_9; uint8_t x_10; 
-x_9 = l_Lean_verboseOption___closed__1;
+x_9 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1;
 x_10 = lean_string_dec_eq(x_4, x_9);
 lean_dec(x_4);
 if (x_10 == 0)
@@ -396,7 +396,7 @@ x_12 = lean_string_dec_eq(x_8, x_11);
 if (x_12 == 0)
 {
 lean_object* x_13; uint8_t x_14; 
-x_13 = l_Lean_verboseOption___closed__1;
+x_13 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1;
 x_14 = lean_string_dec_eq(x_8, x_13);
 lean_dec(x_8);
 if (x_14 == 0)
diff --git a/stage0/stdlib/Lean/Data/Name.c b/stage0/stdlib/Lean/Data/Name.c
index de8a9c3bfd..ae70767549 100644
--- a/stage0/stdlib/Lean/Data/Name.c
+++ b/stage0/stdlib/Lean/Data/Name.c
@@ -16,96 +16,104 @@ extern "C" {
 lean_object* l_Lean_Name_isAtomic___boxed(lean_object*);
 lean_object* l_List_reverse___rarg(lean_object*);
 extern lean_object* l_Lean_mkHole___closed__3;
-lean_object* l_Lean_stringToName;
-lean_object* l_Lean_Name_DecidableRel___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Name_getPrefix_match__1(lean_object*);
+lean_object* l_Lean_Name_components_x27_match__1(lean_object*);
+lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_unreachable_x21___rarg(lean_object*);
+lean_object* l_Lean_NameMap_Lean_Data_Name___instance__5(lean_object*);
 lean_object* l_Lean_NameSet_contains___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_hasLtQuick;
 lean_object* l_Lean_NameMap_find_x3f___rarg(lean_object*, lean_object*);
 lean_object* lean_array_uget(lean_object*, size_t);
-lean_object* l_Lean_NameMap_Inhabited(lean_object*);
-uint8_t l_Lean_Name_lt___main(lean_object*, lean_object*);
 uint8_t l_Std_HashSetImp_contains___at_Lean_NameHashSet_contains___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_Name_replacePrefix___main___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Name_isInternal___boxed(lean_object*);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
+lean_object* l_Lean_Name_getString_x21_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_List_elem___main___at_Lean_NameHashSet_insert___spec__2(lean_object*, lean_object*);
-lean_object* l_Lean_NameSet_HasEmptyc;
-lean_object* l_Lean_Name_isPrefixOf___main___boxed(lean_object*, lean_object*);
-uint8_t l_Lean_Name_DecidableRel(lean_object*, lean_object*);
+lean_object* l_Lean_Name_Lean_Data_Name___instance__3___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Name_isPrefixOf_match__1(lean_object*);
+lean_object* l_Lean_NameSet_Lean_Data_Name___instance__6;
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_getPrefix_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_quickLt___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Name_getNumParts___main___boxed(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_updatePrefix(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1(lean_object*);
+lean_object* l_Lean_NameSet_Lean_Data_Name___instance__7;
 lean_object* l_Std_HashSetImp_expand___at_Lean_NameHashSet_insert___spec__3(lean_object*, lean_object*);
 lean_object* l_Lean_Name_isAnonymous___boxed(lean_object*);
 lean_object* l_Lean_mkNameSimple(lean_object*);
+lean_object* l_Lean_Name_eqStr_match__1(lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 uint8_t l_Lean_Name_isPrefixOf(lean_object*, lean_object*);
+lean_object* l_Lean_NameHashSet_Lean_Data_Name___instance__8;
 lean_object* l_Std_mkHashSetImp___rarg(lean_object*);
 lean_object* l_Lean_Name_lt___boxed(lean_object*, lean_object*);
 lean_object* l_String_splitOn(lean_object*, lean_object*);
+lean_object* l_Lean_Name_isStr_match__1(lean_object*);
+lean_object* l_Lean_Name_isNum_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_isStr___boxed(lean_object*);
-lean_object* l_Lean_Name_getNumParts___main(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_NameHashSet_HasEmptyc;
-lean_object* l_Lean_Name_lt___main___boxed(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
+lean_object* l_Lean_Name_lt_match__1(lean_object*);
+lean_object* l_Lean_Name_isInternal_match__1(lean_object*);
+lean_object* l_Lean_Name_lt_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_updatePrefix_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_NameMap_insert___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
 uint8_t l_Lean_Name_eqStr(lean_object*, lean_object*);
 lean_object* l_Lean_NameMap_find_x3f___rarg___boxed(lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
-lean_object* l_Lean_NameHashSet_Inhabited;
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_Name_appendAfter_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_String_toName(lean_object*);
+lean_object* l_Lean_Name_isAtomic_match__1(lean_object*);
 uint8_t l_Lean_Name_quickLtAux(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Name_updatePrefix_match__1(lean_object*);
 lean_object* l_Lean_Name_components_x27(lean_object*);
 lean_object* l_Lean_NameHashSet_empty;
 lean_object* l_Lean_NameMap_contains(lean_object*);
 lean_object* l_Lean_NameHashSet_contains___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_NameSet_contains___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Name_isInternal_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_hashEx___boxed(lean_object*);
 size_t lean_name_hash(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_NameSet_contains___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Name_getRoot_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Name_isInternal(lean_object*);
+lean_object* l_Lean_Name_appendAfter_match__1(lean_object*);
 lean_object* l_Lean_Name_appendIndexAfter(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_NameSet_contains___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_NameMap_insert(lean_object*);
-uint8_t l_Lean_Name_isPrefixOf___main(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 size_t l_Lean_Name_hash(lean_object*);
 lean_object* l_Nat_repr(lean_object*);
 lean_object* l_Lean_Name_eqStr___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Name_isSuffixOf___main___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Name_replacePrefix_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_quickLtAux_match__1(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
+lean_object* l_Lean_Name_isAnonymous_match__1(lean_object*);
 uint8_t l_Lean_Name_isAtomic(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_NameSet_contains___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_NameHashSet_empty___closed__1;
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 lean_object* l_Lean_Name_getNumParts(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1___rarg___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_NameMap_HasEmptyc(lean_object*);
 lean_object* l_Std_HashSetImp_moveEntries___main___at_Lean_NameHashSet_insert___spec__4(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1(lean_object*);
 size_t lean_usize_modn(size_t, lean_object*);
-lean_object* l_Lean_Name_isInternal___main___boxed(lean_object*);
+lean_object* l_Lean_Lean_Data_Name___instance__2;
+lean_object* l_Lean_Name_appendIndexAfter_match__1(lean_object*);
+lean_object* l_Lean_Name_appendBefore_match__1(lean_object*);
 lean_object* l_Lean_NameMap_find_x3f(lean_object*);
 lean_object* l_Std_HashSetImp_insert___at_Lean_NameHashSet_insert___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_NameSet_empty;
-lean_object* l_Lean_Name_quickLtAux___main___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_stringToName___closed__1;
+lean_object* l_Lean_Name_appendIndexAfter_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_elem___main___at_Lean_NameHashSet_insert___spec__2___boxed(lean_object*, lean_object*);
 extern lean_object* l_Std_HashSet_Inhabited___closed__1;
-uint8_t l_Lean_Name_quickLtAux___main(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1(lean_object*);
 lean_object* l_List_foldl___main___at_String_toName___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_NameMap_contains___rarg___boxed(lean_object*, lean_object*);
@@ -113,58 +121,79 @@ lean_object* l_Lean_Name_quickLtAux___boxed(lean_object*, lean_object*);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
 lean_object* l_Lean_Name_getString_x21(lean_object*);
 uint8_t l_Lean_Name_isStr(lean_object*);
+lean_object* l_Lean_Name_isStr_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_appendAfter(lean_object*, lean_object*);
 uint8_t l_Lean_Name_lt(lean_object*, lean_object*);
+lean_object* l_Lean_Name_isAnonymous_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_getNumParts___boxed(lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1___rarg(lean_object*, lean_object*);
-uint8_t l_Lean_Name_isInternal___main(lean_object*);
 uint8_t l_Std_RBNode_isRed___rarg(lean_object*);
+lean_object* l_Lean_NameHashSet_Lean_Data_Name___instance__9;
 lean_object* l_Lean_Name_getPrefix___boxed(lean_object*);
 lean_object* l_Lean_NameHashSet_insert(lean_object*, lean_object*);
 uint8_t l_Lean_NameHashSet_contains(lean_object*, lean_object*);
-lean_object* l_Lean_Name_components_x27___main(lean_object*);
+lean_object* l_Lean_Name_getRoot_match__1(lean_object*);
 uint8_t l_Lean_Name_isSuffixOf(lean_object*, lean_object*);
+lean_object* l_Lean_Name_getNumParts_match__1(lean_object*);
 uint8_t l_Lean_Name_isAnonymous(lean_object*);
 uint8_t l_Lean_Name_isNum(lean_object*);
-lean_object* l_Lean_NameSet_Inhabited;
+lean_object* lean_panic_fn(lean_object*, lean_object*);
+lean_object* l_Lean_Name_appendBefore_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_quickLtAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_isSuffixOf_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_replacePrefix___boxed(lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Name_Lean_Data_Name___instance__3(lean_object*, lean_object*);
+lean_object* l_Lean_Lean_Data_Name___instance__1___closed__1;
 lean_object* l_List_foldl___main___at_String_toName___spec__1(lean_object*, lean_object*);
-uint8_t l_Lean_Name_isSuffixOf___main(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2(lean_object*);
 lean_object* l_Lean_Name_isSuffixOf___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1___rarg(lean_object*, lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
+lean_object* l_Lean_Name_getNumParts_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Lean_Data_Name___instance__1;
 lean_object* l_Lean_Name_getPrefix(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Name_getRoot___main(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3(lean_object*);
 lean_object* l_String_trim(lean_object*);
+lean_object* l_Lean_Name_getString_x21___closed__2;
+lean_object* l_Lean_Name_isSuffixOf_match__1(lean_object*);
+lean_object* l_Lean_Name_components_x27_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Lean_NameHashSet_insert___spec__5(lean_object*, lean_object*);
+lean_object* l_Lean_Name_getString_x21___closed__1;
 lean_object* lean_mk_array(lean_object*, lean_object*);
 lean_object* l_Lean_Name_getString_x21___boxed(lean_object*);
 lean_object* l_Lean_Name_isNum___boxed(lean_object*);
 lean_object* l_Std_mkHashSet___at_Lean_NameHashSet_empty___spec__1(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3(lean_object*);
 uint8_t l_Lean_NameSet_contains(lean_object*, lean_object*);
 lean_object* l_Lean_Name_isPrefixOf___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_NameSet_insert(lean_object*, lean_object*);
 lean_object* l_Std_HashSetImp_contains___at_Lean_NameHashSet_contains___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Name_appendBefore(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1(lean_object*);
 lean_object* l_List_replace___main___at_Lean_NameHashSet_insert___spec__6(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Name_getRoot___main___boxed(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_getString_x21___closed__4;
+lean_object* l_Lean_Name_getString_x21_match__1(lean_object*);
+lean_object* l_Lean_NameMap_Lean_Data_Name___instance__4(lean_object*);
 lean_object* l_Lean_mkNameMap(lean_object*);
 extern lean_object* l_System_FilePath_dirName___closed__1;
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_Name_isNum_match__1(lean_object*);
+lean_object* l_Lean_Name_replacePrefix_match__1(lean_object*);
+lean_object* l_Lean_Name_eqStr_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_getRoot___boxed(lean_object*);
 lean_object* l_Lean_Name_getRoot(lean_object*);
+lean_object* l_Lean_Name_isAtomic_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_String_Inhabited;
 lean_object* l_Lean_Name_replacePrefix(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_replace___main___at_Lean_NameHashSet_insert___spec__6___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_components(lean_object*);
 lean_object* lean_name_mk_numeral(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1(lean_object*);
+lean_object* l_Lean_Name_isPrefixOf_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Util_2__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_dec_lt(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-static lean_object* _init_l_Lean_stringToName___closed__1() {
+static lean_object* _init_l_Lean_Lean_Data_Name___instance__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -172,11 +201,19 @@ x_1 = lean_alloc_closure((void*)(l_Lean_mkNameSimple), 1, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_stringToName() {
+static lean_object* _init_l_Lean_Lean_Data_Name___instance__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_stringToName___closed__1;
+x_1 = l_Lean_Lean_Data_Name___instance__1___closed__1;
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Lean_Data_Name___instance__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_Lean_Lean_Data_Name___instance__1___closed__1;
 return x_1;
 }
 }
@@ -198,19 +235,75 @@ x_3 = lean_box_usize(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Name_getPrefix_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+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; size_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_10 = lean_box_usize(x_9);
+x_11 = lean_apply_3(x_3, x_7, x_8, x_10);
+return x_11;
+}
+default: 
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_box_usize(x_14);
+x_16 = lean_apply_3(x_4, x_12, x_13, x_15);
+return x_16;
+}
+}
+}
+}
+lean_object* l_Lean_Name_getPrefix_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_getPrefix_match__1___rarg), 4, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Name_getPrefix(lean_object* x_1) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-return x_1;
+lean_object* x_2; 
+x_2 = lean_box(0);
+return x_2;
 }
 else
 {
-lean_object* x_2; 
-x_2 = lean_ctor_get(x_1, 0);
-lean_inc(x_2);
-return x_2;
+lean_object* x_3; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+return x_3;
 }
 }
 }
@@ -223,46 +316,121 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Name_getRoot___main(lean_object* x_1) {
+lean_object* l_Lean_Name_getRoot_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-if (lean_obj_tag(x_1) == 0)
+switch (lean_obj_tag(x_1)) {
+case 0:
 {
-return x_1;
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_7 = lean_box(0);
+x_8 = lean_apply_1(x_2, x_7);
+return x_8;
+}
+case 1:
+{
+lean_object* x_9; 
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_2);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; size_t x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_5);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get_usize(x_1, 2);
+x_12 = lean_box_usize(x_11);
+x_13 = lean_apply_3(x_3, x_1, x_10, x_12);
+return x_13;
 }
 else
 {
-lean_object* x_2; 
-x_2 = lean_ctor_get(x_1, 0);
-if (lean_obj_tag(x_2) == 0)
-{
-lean_inc(x_1);
-return x_1;
-}
-else
-{
-x_1 = x_2;
-goto _start;
-}
-}
-}
-}
-lean_object* l_Lean_Name_getRoot___main___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Name_getRoot___main(x_1);
+lean_object* x_14; size_t x_15; lean_object* x_16; lean_object* x_17; 
+lean_dec(x_3);
+x_14 = lean_ctor_get(x_1, 1);
+lean_inc(x_14);
+x_15 = lean_ctor_get_usize(x_1, 2);
 lean_dec(x_1);
+x_16 = lean_box_usize(x_15);
+x_17 = lean_apply_3(x_5, x_9, x_14, x_16);
+return x_17;
+}
+}
+default: 
+{
+lean_object* x_18; 
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_18 = lean_ctor_get(x_1, 0);
+lean_inc(x_18);
+if (lean_obj_tag(x_18) == 0)
+{
+lean_object* x_19; size_t x_20; lean_object* x_21; lean_object* x_22; 
+lean_dec(x_6);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+x_20 = lean_ctor_get_usize(x_1, 2);
+x_21 = lean_box_usize(x_20);
+x_22 = lean_apply_3(x_4, x_1, x_19, x_21);
+return x_22;
+}
+else
+{
+lean_object* x_23; size_t x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_4);
+x_23 = lean_ctor_get(x_1, 1);
+lean_inc(x_23);
+x_24 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_25 = lean_box_usize(x_24);
+x_26 = lean_apply_3(x_6, x_18, x_23, x_25);
+return x_26;
+}
+}
+}
+}
+}
+lean_object* l_Lean_Name_getRoot_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_getRoot_match__1___rarg), 6, 0);
 return x_2;
 }
 }
 lean_object* l_Lean_Name_getRoot(lean_object* x_1) {
 _start:
 {
+if (lean_obj_tag(x_1) == 0)
+{
 lean_object* x_2; 
-x_2 = l_Lean_Name_getRoot___main(x_1);
+x_2 = lean_box(0);
 return x_2;
 }
+else
+{
+lean_object* x_3; 
+x_3 = lean_ctor_get(x_1, 0);
+if (lean_obj_tag(x_3) == 0)
+{
+lean_inc(x_1);
+return x_1;
+}
+else
+{
+x_1 = x_3;
+goto _start;
+}
+}
+}
 }
 lean_object* l_Lean_Name_getRoot___boxed(lean_object* x_1) {
 _start:
@@ -273,6 +441,77 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_Lean_Name_getString_x21_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 1)
+{
+lean_object* x_4; lean_object* x_5; size_t x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_7 = lean_box_usize(x_6);
+x_8 = lean_apply_3(x_2, x_4, x_5, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+}
+lean_object* l_Lean_Name_getString_x21_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_getString_x21_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Name_getString_x21___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("Lean.Data.Name");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Name_getString_x21___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("Lean.Name.getString!");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Name_getString_x21___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("unreachable code has been reached");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_Name_getString_x21___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_1 = l_Lean_Name_getString_x21___closed__1;
+x_2 = l_Lean_Name_getString_x21___closed__2;
+x_3 = lean_unsigned_to_nat(34u);
+x_4 = lean_unsigned_to_nat(15u);
+x_5 = l_Lean_Name_getString_x21___closed__3;
+x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
+return x_6;
+}
+}
 lean_object* l_Lean_Name_getString_x21(lean_object* x_1) {
 _start:
 {
@@ -285,10 +524,11 @@ return x_2;
 }
 else
 {
-lean_object* x_3; lean_object* x_4; 
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_3 = l_String_Inhabited;
-x_4 = l_unreachable_x21___rarg(x_3);
-return x_4;
+x_4 = l_Lean_Name_getString_x21___closed__4;
+x_5 = lean_panic_fn(x_3, x_4);
+return x_5;
 }
 }
 }
@@ -301,7 +541,61 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Name_getNumParts___main(lean_object* x_1) {
+lean_object* l_Lean_Name_getNumParts_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+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; size_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_10 = lean_box_usize(x_9);
+x_11 = lean_apply_3(x_3, x_7, x_8, x_10);
+return x_11;
+}
+default: 
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_box_usize(x_14);
+x_16 = lean_apply_3(x_4, x_12, x_13, x_15);
+return x_16;
+}
+}
+}
+}
+lean_object* l_Lean_Name_getNumParts_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_getNumParts_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Name_getNumParts(lean_object* x_1) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -314,7 +608,7 @@ else
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_3 = lean_ctor_get(x_1, 0);
-x_4 = l_Lean_Name_getNumParts___main(x_3);
+x_4 = l_Lean_Name_getNumParts(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_add(x_4, x_5);
 lean_dec(x_4);
@@ -322,23 +616,6 @@ return x_6;
 }
 }
 }
-lean_object* l_Lean_Name_getNumParts___main___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Name_getNumParts___main(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_Name_getNumParts(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Name_getNumParts___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_Name_getNumParts___boxed(lean_object* x_1) {
 _start:
 {
@@ -348,37 +625,146 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_Lean_Name_updatePrefix_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_6; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_6 = lean_apply_1(x_3, x_2);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; size_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_5);
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_10 = lean_box_usize(x_9);
+x_11 = lean_apply_4(x_4, x_7, x_8, x_10, x_2);
+return x_11;
+}
+default: 
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_box_usize(x_14);
+x_16 = lean_apply_4(x_5, x_12, x_13, x_15, x_2);
+return x_16;
+}
+}
+}
+}
+lean_object* l_Lean_Name_updatePrefix_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_updatePrefix_match__1___rarg), 5, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Name_updatePrefix(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
 case 0:
 {
+lean_object* x_3; 
 lean_dec(x_2);
-return x_1;
+x_3 = lean_box(0);
+return x_3;
 }
 case 1:
 {
-lean_object* x_3; lean_object* x_4; 
-x_3 = lean_ctor_get(x_1, 1);
-lean_inc(x_3);
+lean_object* x_4; lean_object* x_5; 
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
 lean_dec(x_1);
-x_4 = lean_name_mk_string(x_2, x_3);
-return x_4;
+x_5 = lean_name_mk_string(x_2, x_4);
+return x_5;
 }
 default: 
 {
-lean_object* x_5; lean_object* x_6; 
-x_5 = lean_ctor_get(x_1, 1);
-lean_inc(x_5);
+lean_object* x_6; lean_object* x_7; 
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
 lean_dec(x_1);
-x_6 = lean_name_mk_numeral(x_2, x_5);
+x_7 = lean_name_mk_numeral(x_2, x_6);
+return x_7;
+}
+}
+}
+}
+lean_object* l_Lean_Name_components_x27_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+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; size_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_10 = lean_box_usize(x_9);
+x_11 = lean_apply_3(x_3, x_7, x_8, x_10);
+return x_11;
+}
+default: 
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_box_usize(x_14);
+x_16 = lean_apply_3(x_4, x_12, x_13, x_15);
+return x_16;
 }
 }
 }
-lean_object* l_Lean_Name_components_x27___main(lean_object* x_1) {
+}
+lean_object* l_Lean_Name_components_x27_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_components_x27_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Name_components_x27(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -398,7 +784,7 @@ lean_inc(x_4);
 lean_dec(x_1);
 x_5 = lean_box(0);
 x_6 = lean_name_mk_string(x_5, x_4);
-x_7 = l_Lean_Name_components_x27___main(x_3);
+x_7 = l_Lean_Name_components_x27(x_3);
 x_8 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_8, 0, x_6);
 lean_ctor_set(x_8, 1, x_7);
@@ -414,7 +800,7 @@ lean_inc(x_10);
 lean_dec(x_1);
 x_11 = lean_box(0);
 x_12 = lean_name_mk_numeral(x_11, x_10);
-x_13 = l_Lean_Name_components_x27___main(x_9);
+x_13 = l_Lean_Name_components_x27(x_9);
 x_14 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_14, 0, x_12);
 lean_ctor_set(x_14, 1, x_13);
@@ -423,23 +809,61 @@ return x_14;
 }
 }
 }
-lean_object* l_Lean_Name_components_x27(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_Name_components_x27___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_Name_components(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Name_components_x27___main(x_1);
+x_2 = l_Lean_Name_components_x27(x_1);
 x_3 = l_List_reverse___rarg(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Name_eqStr_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 1)
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 0)
+{
+lean_object* x_6; size_t x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_8 = lean_box_usize(x_7);
+x_9 = lean_apply_3(x_3, x_6, x_8, x_2);
+return x_9;
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_5);
+lean_dec(x_3);
+x_10 = lean_apply_2(x_4, x_1, x_2);
+return x_10;
+}
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_3);
+x_11 = lean_apply_2(x_4, x_1, x_2);
+return x_11;
+}
+}
+}
+lean_object* l_Lean_Name_eqStr_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_eqStr_match__1___rarg), 4, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Name_eqStr(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -480,7 +904,71 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_Name_replacePrefix___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Name_replacePrefix_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_dec(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_8; 
+lean_dec(x_5);
+x_8 = lean_apply_1(x_4, x_3);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_4);
+x_9 = lean_apply_2(x_5, x_2, x_3);
+return x_9;
+}
+}
+case 1:
+{
+lean_object* x_10; lean_object* x_11; size_t x_12; lean_object* x_13; lean_object* x_14; 
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_1, 1);
+lean_inc(x_11);
+x_12 = lean_ctor_get_usize(x_1, 2);
+x_13 = lean_box_usize(x_12);
+x_14 = lean_apply_6(x_6, x_1, x_10, x_11, x_13, x_2, x_3);
+return x_14;
+}
+default: 
+{
+lean_object* x_15; lean_object* x_16; size_t x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_15 = lean_ctor_get(x_1, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 1);
+lean_inc(x_16);
+x_17 = lean_ctor_get_usize(x_1, 2);
+x_18 = lean_box_usize(x_17);
+x_19 = lean_apply_6(x_7, x_1, x_15, x_16, x_18, x_2, x_3);
+return x_19;
+}
+}
+}
+}
+lean_object* l_Lean_Name_replacePrefix_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_replacePrefix_match__1___rarg), 7, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Name_replacePrefix(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -493,53 +981,55 @@ return x_3;
 }
 else
 {
-return x_1;
+lean_object* x_4; 
+x_4 = lean_box(0);
+return x_4;
 }
 }
 case 1:
 {
-lean_object* x_4; lean_object* x_5; uint8_t x_6; 
-x_4 = lean_ctor_get(x_1, 0);
-lean_inc(x_4);
-x_5 = lean_ctor_get(x_1, 1);
+lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_5 = lean_ctor_get(x_1, 0);
 lean_inc(x_5);
-x_6 = lean_name_eq(x_1, x_2);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+x_7 = lean_name_eq(x_1, x_2);
 lean_dec(x_1);
-if (x_6 == 0)
+if (x_7 == 0)
 {
-lean_object* x_7; lean_object* x_8; 
-x_7 = l_Lean_Name_replacePrefix___main(x_4, x_2, x_3);
-x_8 = lean_name_mk_string(x_7, x_5);
-return x_8;
+lean_object* x_8; lean_object* x_9; 
+x_8 = l_Lean_Name_replacePrefix(x_5, x_2, x_3);
+x_9 = lean_name_mk_string(x_8, x_6);
+return x_9;
 }
 else
 {
+lean_dec(x_6);
 lean_dec(x_5);
-lean_dec(x_4);
 lean_inc(x_3);
 return x_3;
 }
 }
 default: 
 {
-lean_object* x_9; lean_object* x_10; uint8_t x_11; 
-x_9 = lean_ctor_get(x_1, 0);
-lean_inc(x_9);
-x_10 = lean_ctor_get(x_1, 1);
+lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_10 = lean_ctor_get(x_1, 0);
 lean_inc(x_10);
-x_11 = lean_name_eq(x_1, x_2);
+x_11 = lean_ctor_get(x_1, 1);
+lean_inc(x_11);
+x_12 = lean_name_eq(x_1, x_2);
 lean_dec(x_1);
-if (x_11 == 0)
+if (x_12 == 0)
 {
-lean_object* x_12; lean_object* x_13; 
-x_12 = l_Lean_Name_replacePrefix___main(x_9, x_2, x_3);
-x_13 = lean_name_mk_numeral(x_12, x_10);
-return x_13;
+lean_object* x_13; lean_object* x_14; 
+x_13 = l_Lean_Name_replacePrefix(x_10, x_2, x_3);
+x_14 = lean_name_mk_numeral(x_13, x_11);
+return x_14;
 }
 else
 {
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
 lean_inc(x_3);
 return x_3;
 }
@@ -547,24 +1037,6 @@ return x_3;
 }
 }
 }
-lean_object* l_Lean_Name_replacePrefix___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Name_replacePrefix___main(x_1, x_2, x_3);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_4;
-}
-}
-lean_object* l_Lean_Name_replacePrefix(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Lean_Name_replacePrefix___main(x_1, x_2, x_3);
-return x_4;
-}
-}
 lean_object* l_Lean_Name_replacePrefix___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -575,51 +1047,84 @@ lean_dec(x_2);
 return x_4;
 }
 }
-uint8_t l_Lean_Name_isPrefixOf___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Name_isPrefixOf_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
-if (lean_obj_tag(x_2) == 0)
+switch (lean_obj_tag(x_2)) {
+case 0:
 {
-uint8_t x_3; 
-x_3 = lean_name_eq(x_1, x_2);
-return x_3;
+lean_object* x_6; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_6 = lean_apply_1(x_3, x_1);
+return x_6;
 }
-else
+case 1:
 {
-lean_object* x_4; uint8_t x_5; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = lean_name_eq(x_1, x_2);
-if (x_5 == 0)
+lean_object* x_7; lean_object* x_8; size_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_2, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_2, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_usize(x_2, 2);
+x_10 = lean_box_usize(x_9);
+x_11 = lean_apply_5(x_5, x_1, x_2, x_7, x_8, x_10);
+return x_11;
+}
+default: 
 {
-x_2 = x_4;
-goto _start;
-}
-else
-{
-uint8_t x_7; 
-x_7 = 1;
-return x_7;
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_5);
+lean_dec(x_3);
+x_12 = lean_ctor_get(x_2, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_2, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_2, 2);
+x_15 = lean_box_usize(x_14);
+x_16 = lean_apply_5(x_4, x_1, x_2, x_12, x_13, x_15);
+return x_16;
 }
 }
 }
 }
-lean_object* l_Lean_Name_isPrefixOf___main___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Name_isPrefixOf_match__1(lean_object* x_1) {
 _start:
 {
-uint8_t x_3; lean_object* x_4; 
-x_3 = l_Lean_Name_isPrefixOf___main(x_1, x_2);
-lean_dec(x_2);
-lean_dec(x_1);
-x_4 = lean_box(x_3);
-return x_4;
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_isPrefixOf_match__1___rarg), 5, 0);
+return x_2;
 }
 }
 uint8_t l_Lean_Name_isPrefixOf(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_3; 
-x_3 = l_Lean_Name_isPrefixOf___main(x_1, x_2);
-return x_3;
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_3; uint8_t x_4; 
+x_3 = lean_box(0);
+x_4 = lean_name_eq(x_1, x_3);
+return x_4;
+}
+else
+{
+lean_object* x_5; uint8_t x_6; 
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_name_eq(x_1, x_2);
+if (x_6 == 0)
+{
+x_2 = x_5;
+goto _start;
+}
+else
+{
+uint8_t x_8; 
+x_8 = 1;
+return x_8;
+}
+}
 }
 }
 lean_object* l_Lean_Name_isPrefixOf___boxed(lean_object* x_1, lean_object* x_2) {
@@ -633,7 +1138,97 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-uint8_t l_Lean_Name_isSuffixOf___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Name_isSuffixOf_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_7; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_7 = lean_apply_1(x_3, x_2);
+return x_7;
+}
+case 1:
+{
+lean_dec(x_5);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 1)
+{
+lean_object* x_8; lean_object* x_9; size_t x_10; lean_object* x_11; lean_object* x_12; size_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_6);
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 1);
+lean_inc(x_9);
+x_10 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_11 = lean_ctor_get(x_2, 0);
+lean_inc(x_11);
+x_12 = lean_ctor_get(x_2, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_14 = lean_box_usize(x_10);
+x_15 = lean_box_usize(x_13);
+x_16 = lean_apply_6(x_4, x_8, x_9, x_14, x_11, x_12, x_15);
+return x_16;
+}
+else
+{
+lean_object* x_17; 
+lean_dec(x_4);
+x_17 = lean_apply_2(x_6, x_1, x_2);
+return x_17;
+}
+}
+default: 
+{
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 2)
+{
+lean_object* x_18; lean_object* x_19; size_t x_20; lean_object* x_21; lean_object* x_22; size_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_6);
+x_18 = lean_ctor_get(x_1, 0);
+lean_inc(x_18);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+x_20 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_21 = lean_ctor_get(x_2, 0);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_2, 1);
+lean_inc(x_22);
+x_23 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_24 = lean_box_usize(x_20);
+x_25 = lean_box_usize(x_23);
+x_26 = lean_apply_6(x_5, x_18, x_19, x_24, x_21, x_22, x_25);
+return x_26;
+}
+else
+{
+lean_object* x_27; 
+lean_dec(x_5);
+x_27 = lean_apply_2(x_6, x_1, x_2);
+return x_27;
+}
+}
+}
+}
+}
+lean_object* l_Lean_Name_isSuffixOf_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_isSuffixOf_match__1___rarg), 6, 0);
+return x_2;
+}
+}
+uint8_t l_Lean_Name_isSuffixOf(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -706,25 +1301,6 @@ return x_19;
 }
 }
 }
-lean_object* l_Lean_Name_isSuffixOf___main___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l_Lean_Name_isSuffixOf___main(x_1, x_2);
-lean_dec(x_2);
-lean_dec(x_1);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-uint8_t l_Lean_Name_isSuffixOf(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = l_Lean_Name_isSuffixOf___main(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_Name_isSuffixOf___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -736,7 +1312,139 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-uint8_t l_Lean_Name_lt___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Name_lt_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+x_9 = lean_box(0);
+x_10 = lean_apply_1(x_3, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_3);
+x_11 = lean_apply_1(x_4, x_2);
+return x_11;
+}
+}
+case 1:
+{
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 1)
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; size_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_2, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_2, 1);
+lean_inc(x_16);
+x_17 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_18 = lean_box_usize(x_14);
+x_19 = lean_box_usize(x_17);
+x_20 = lean_apply_6(x_7, x_12, x_13, x_18, x_15, x_16, x_19);
+return x_20;
+}
+else
+{
+lean_object* x_21; 
+lean_dec(x_7);
+x_21 = lean_apply_2(x_8, x_1, x_2);
+return x_21;
+}
+}
+default: 
+{
+lean_dec(x_7);
+lean_dec(x_4);
+lean_dec(x_3);
+switch (lean_obj_tag(x_2)) {
+case 0:
+{
+lean_object* x_22; 
+lean_dec(x_6);
+lean_dec(x_5);
+x_22 = lean_apply_2(x_8, x_1, x_2);
+return x_22;
+}
+case 1:
+{
+lean_object* x_23; lean_object* x_24; size_t x_25; lean_object* x_26; lean_object* x_27; size_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_8);
+lean_dec(x_5);
+x_23 = lean_ctor_get(x_1, 0);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_1, 1);
+lean_inc(x_24);
+x_25 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_26 = lean_ctor_get(x_2, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_2, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_29 = lean_box_usize(x_25);
+x_30 = lean_box_usize(x_28);
+x_31 = lean_apply_6(x_6, x_23, x_24, x_29, x_26, x_27, x_30);
+return x_31;
+}
+default: 
+{
+lean_object* x_32; lean_object* x_33; size_t x_34; lean_object* x_35; lean_object* x_36; size_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_8);
+lean_dec(x_6);
+x_32 = lean_ctor_get(x_1, 0);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_1, 1);
+lean_inc(x_33);
+x_34 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_35 = lean_ctor_get(x_2, 0);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_2, 1);
+lean_inc(x_36);
+x_37 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_38 = lean_box_usize(x_34);
+x_39 = lean_box_usize(x_37);
+x_40 = lean_apply_6(x_5, x_32, x_33, x_38, x_35, x_36, x_39);
+return x_40;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Name_lt_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_lt_match__1___rarg), 8, 0);
+return x_2;
+}
+}
+uint8_t l_Lean_Name_lt(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -764,7 +1472,7 @@ x_5 = lean_ctor_get(x_1, 0);
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = lean_ctor_get(x_2, 0);
 x_8 = lean_ctor_get(x_2, 1);
-x_9 = l_Lean_Name_lt___main(x_5, x_7);
+x_9 = l_Lean_Name_lt(x_5, x_7);
 if (x_9 == 0)
 {
 uint8_t x_10; 
@@ -816,7 +1524,7 @@ x_16 = lean_ctor_get(x_1, 0);
 x_17 = lean_ctor_get(x_1, 1);
 x_18 = lean_ctor_get(x_2, 0);
 x_19 = lean_ctor_get(x_2, 1);
-x_20 = l_Lean_Name_lt___main(x_16, x_18);
+x_20 = l_Lean_Name_lt(x_16, x_18);
 if (x_20 == 0)
 {
 uint8_t x_21; 
@@ -844,25 +1552,6 @@ return x_23;
 }
 }
 }
-lean_object* l_Lean_Name_lt___main___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l_Lean_Name_lt___main(x_1, x_2);
-lean_dec(x_2);
-lean_dec(x_1);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-uint8_t l_Lean_Name_lt(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = l_Lean_Name_lt___main(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_Name_lt___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -874,7 +1563,139 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-uint8_t l_Lean_Name_quickLtAux___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Name_quickLtAux_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+x_9 = lean_box(0);
+x_10 = lean_apply_1(x_3, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_3);
+x_11 = lean_apply_1(x_4, x_2);
+return x_11;
+}
+}
+case 1:
+{
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 1)
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; size_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+lean_dec(x_8);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_2, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_2, 1);
+lean_inc(x_16);
+x_17 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_18 = lean_box_usize(x_14);
+x_19 = lean_box_usize(x_17);
+x_20 = lean_apply_6(x_7, x_12, x_13, x_18, x_15, x_16, x_19);
+return x_20;
+}
+else
+{
+lean_object* x_21; 
+lean_dec(x_7);
+x_21 = lean_apply_2(x_8, x_1, x_2);
+return x_21;
+}
+}
+default: 
+{
+lean_dec(x_7);
+lean_dec(x_4);
+lean_dec(x_3);
+switch (lean_obj_tag(x_2)) {
+case 0:
+{
+lean_object* x_22; 
+lean_dec(x_6);
+lean_dec(x_5);
+x_22 = lean_apply_2(x_8, x_1, x_2);
+return x_22;
+}
+case 1:
+{
+lean_object* x_23; lean_object* x_24; size_t x_25; lean_object* x_26; lean_object* x_27; size_t x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_8);
+lean_dec(x_5);
+x_23 = lean_ctor_get(x_1, 0);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_1, 1);
+lean_inc(x_24);
+x_25 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_26 = lean_ctor_get(x_2, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_2, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_29 = lean_box_usize(x_25);
+x_30 = lean_box_usize(x_28);
+x_31 = lean_apply_6(x_6, x_23, x_24, x_29, x_26, x_27, x_30);
+return x_31;
+}
+default: 
+{
+lean_object* x_32; lean_object* x_33; size_t x_34; lean_object* x_35; lean_object* x_36; size_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+lean_dec(x_8);
+lean_dec(x_6);
+x_32 = lean_ctor_get(x_1, 0);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_1, 1);
+lean_inc(x_33);
+x_34 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_35 = lean_ctor_get(x_2, 0);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_2, 1);
+lean_inc(x_36);
+x_37 = lean_ctor_get_usize(x_2, 2);
+lean_dec(x_2);
+x_38 = lean_box_usize(x_34);
+x_39 = lean_box_usize(x_37);
+x_40 = lean_apply_6(x_5, x_32, x_33, x_38, x_35, x_36, x_39);
+return x_40;
+}
+}
+}
+}
+}
+}
+lean_object* l_Lean_Name_quickLtAux_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_quickLtAux_match__1___rarg), 8, 0);
+return x_2;
+}
+}
+uint8_t l_Lean_Name_quickLtAux(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -982,25 +1803,6 @@ return x_23;
 }
 }
 }
-lean_object* l_Lean_Name_quickLtAux___main___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l_Lean_Name_quickLtAux___main(x_1, x_2);
-lean_dec(x_2);
-lean_dec(x_1);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-uint8_t l_Lean_Name_quickLtAux(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = l_Lean_Name_quickLtAux___main(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_Name_quickLtAux___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1026,7 +1828,7 @@ x_6 = x_4 < x_3;
 if (x_6 == 0)
 {
 uint8_t x_7; 
-x_7 = l_Lean_Name_quickLtAux___main(x_1, x_2);
+x_7 = l_Lean_Name_quickLtAux(x_1, x_2);
 return x_7;
 }
 else
@@ -1063,7 +1865,7 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-uint8_t l_Lean_Name_DecidableRel(lean_object* x_1, lean_object* x_2) {
+uint8_t l_Lean_Name_Lean_Data_Name___instance__3(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
@@ -1071,17 +1873,51 @@ x_3 = l_Lean_Name_quickLt(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Lean_Name_DecidableRel___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Name_Lean_Data_Name___instance__3___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l_Lean_Name_DecidableRel(x_1, x_2);
+x_3 = l_Lean_Name_Lean_Data_Name___instance__3(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
 }
+lean_object* l_Lean_Name_appendAfter_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 1)
+{
+lean_object* x_5; lean_object* x_6; size_t x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_4);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_8 = lean_box_usize(x_7);
+x_9 = lean_apply_4(x_3, x_5, x_6, x_8, x_2);
+return x_9;
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_3);
+x_10 = lean_apply_2(x_4, x_1, x_2);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_Name_appendAfter_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_appendAfter_match__1___rarg), 4, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Name_appendAfter(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1106,85 +1942,217 @@ return x_7;
 }
 }
 }
-lean_object* l_Lean_Name_appendIndexAfter(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Name_appendIndexAfter_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_3; 
 if (lean_obj_tag(x_1) == 1)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-x_9 = lean_ctor_get(x_1, 0);
-lean_inc(x_9);
-x_10 = lean_ctor_get(x_1, 1);
-lean_inc(x_10);
+lean_object* x_5; lean_object* x_6; size_t x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_4);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+x_7 = lean_ctor_get_usize(x_1, 2);
 lean_dec(x_1);
-x_11 = l_Lean_mkHole___closed__3;
-x_12 = lean_string_append(x_10, x_11);
-x_13 = l_Nat_repr(x_2);
-x_14 = lean_string_append(x_12, x_13);
-lean_dec(x_13);
-x_15 = lean_name_mk_string(x_9, x_14);
-return x_15;
+x_8 = lean_box_usize(x_7);
+x_9 = lean_apply_4(x_3, x_5, x_6, x_8, x_2);
+return x_9;
 }
 else
 {
-lean_object* x_16; 
-x_16 = lean_box(0);
-x_3 = x_16;
-goto block_8;
-}
-block_8:
-{
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+lean_object* x_10; 
 lean_dec(x_3);
-x_4 = l_Nat_repr(x_2);
-x_5 = l_Lean_mkHole___closed__3;
-x_6 = lean_string_append(x_5, x_4);
-lean_dec(x_4);
-x_7 = lean_name_mk_string(x_1, x_6);
-return x_7;
+x_10 = lean_apply_2(x_4, x_1, x_2);
+return x_10;
 }
 }
 }
+lean_object* l_Lean_Name_appendIndexAfter_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_appendIndexAfter_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Name_appendIndexAfter(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+if (lean_obj_tag(x_1) == 1)
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = l_Lean_mkHole___closed__3;
+x_6 = lean_string_append(x_4, x_5);
+x_7 = l_Nat_repr(x_2);
+x_8 = lean_string_append(x_6, x_7);
+lean_dec(x_7);
+x_9 = lean_name_mk_string(x_3, x_8);
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_10 = l_Nat_repr(x_2);
+x_11 = l_Lean_mkHole___closed__3;
+x_12 = lean_string_append(x_11, x_10);
+lean_dec(x_10);
+x_13 = lean_name_mk_string(x_1, x_12);
+return x_13;
+}
+}
+}
+lean_object* l_Lean_Name_appendBefore_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_6; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_6 = lean_apply_1(x_3, x_2);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; size_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_5);
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_10 = lean_box_usize(x_9);
+x_11 = lean_apply_4(x_4, x_7, x_8, x_10, x_2);
+return x_11;
+}
+default: 
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_box_usize(x_14);
+x_16 = lean_apply_4(x_5, x_12, x_13, x_15, x_2);
+return x_16;
+}
+}
+}
+}
+lean_object* l_Lean_Name_appendBefore_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_appendBefore_match__1___rarg), 5, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Name_appendBefore(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
 case 0:
 {
-lean_object* x_3; 
-x_3 = lean_name_mk_string(x_1, x_2);
-return x_3;
+lean_object* x_3; lean_object* x_4; 
+x_3 = lean_box(0);
+x_4 = lean_name_mk_string(x_3, x_2);
+return x_4;
 }
 case 1:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_4 = lean_ctor_get(x_1, 0);
-lean_inc(x_4);
-x_5 = lean_ctor_get(x_1, 1);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_5 = lean_ctor_get(x_1, 0);
 lean_inc(x_5);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
 lean_dec(x_1);
-x_6 = lean_string_append(x_2, x_5);
-lean_dec(x_5);
-x_7 = lean_name_mk_string(x_4, x_6);
-return x_7;
+x_7 = lean_string_append(x_2, x_6);
+lean_dec(x_6);
+x_8 = lean_name_mk_string(x_5, x_7);
+return x_8;
 }
 default: 
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_9 = lean_ctor_get(x_1, 0);
 lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_dec(x_1);
-x_10 = lean_name_mk_string(x_8, x_2);
-x_11 = lean_name_mk_numeral(x_10, x_9);
-return x_11;
+x_11 = lean_name_mk_string(x_9, x_2);
+x_12 = lean_name_mk_numeral(x_11, x_10);
+return x_12;
 }
 }
 }
 }
-uint8_t l_Lean_Name_isInternal___main(lean_object* x_1) {
+lean_object* l_Lean_Name_isInternal_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_5; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_5 = lean_apply_1(x_4, x_1);
+return x_5;
+}
+case 1:
+{
+lean_object* x_6; lean_object* x_7; size_t x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+x_8 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_9 = lean_box_usize(x_8);
+x_10 = lean_apply_3(x_2, x_6, x_7, x_9);
+return x_10;
+}
+default: 
+{
+lean_object* x_11; lean_object* x_12; size_t x_13; lean_object* x_14; lean_object* x_15; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_11 = lean_ctor_get(x_1, 0);
+lean_inc(x_11);
+x_12 = lean_ctor_get(x_1, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_14 = lean_box_usize(x_13);
+x_15 = lean_apply_3(x_3, x_11, x_12, x_14);
+return x_15;
+}
+}
+}
+}
+lean_object* l_Lean_Name_isInternal_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_isInternal_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+uint8_t l_Lean_Name_isInternal(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -1225,24 +2193,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Lean_Name_isInternal___main___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_Name_isInternal___main(x_1);
-lean_dec(x_1);
-x_3 = lean_box(x_2);
-return x_3;
-}
-}
-uint8_t l_Lean_Name_isInternal(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; 
-x_2 = l_Lean_Name_isInternal___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_Name_isInternal___boxed(lean_object* x_1) {
 _start:
 {
@@ -1253,6 +2203,87 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Name_isAtomic_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+case 1:
+{
+lean_object* x_8; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; size_t x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_5);
+x_9 = lean_ctor_get(x_1, 1);
+lean_inc(x_9);
+x_10 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_11 = lean_box_usize(x_10);
+x_12 = lean_apply_2(x_3, x_9, x_11);
+return x_12;
+}
+else
+{
+lean_object* x_13; 
+lean_dec(x_8);
+lean_dec(x_3);
+x_13 = lean_apply_1(x_5, x_1);
+return x_13;
+}
+}
+default: 
+{
+lean_object* x_14; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+if (lean_obj_tag(x_14) == 0)
+{
+lean_object* x_15; size_t x_16; lean_object* x_17; lean_object* x_18; 
+lean_dec(x_5);
+x_15 = lean_ctor_get(x_1, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_17 = lean_box_usize(x_16);
+x_18 = lean_apply_2(x_4, x_15, x_17);
+return x_18;
+}
+else
+{
+lean_object* x_19; 
+lean_dec(x_14);
+lean_dec(x_4);
+x_19 = lean_apply_1(x_5, x_1);
+return x_19;
+}
+}
+}
+}
+}
+lean_object* l_Lean_Name_isAtomic_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_isAtomic_match__1___rarg), 5, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Name_isAtomic(lean_object* x_1) {
 _start:
 {
@@ -1291,6 +2322,34 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Name_isAnonymous_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; 
+lean_dec(x_2);
+x_6 = lean_apply_1(x_3, x_1);
+return x_6;
+}
+}
+}
+lean_object* l_Lean_Name_isAnonymous_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_isAnonymous_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Name_isAnonymous(lean_object* x_1) {
 _start:
 {
@@ -1318,6 +2377,40 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Name_isStr_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 1)
+{
+lean_object* x_4; lean_object* x_5; size_t x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_7 = lean_box_usize(x_6);
+x_8 = lean_apply_3(x_2, x_4, x_5, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+}
+lean_object* l_Lean_Name_isStr_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_isStr_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Name_isStr(lean_object* x_1) {
 _start:
 {
@@ -1345,6 +2438,40 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Name_isNum_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 2)
+{
+lean_object* x_4; lean_object* x_5; size_t x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_7 = lean_box_usize(x_6);
+x_8 = lean_apply_3(x_2, x_4, x_5, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+}
+lean_object* l_Lean_Name_isNum_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Name_isNum_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Name_isNum(lean_object* x_1) {
 _start:
 {
@@ -1380,7 +2507,7 @@ x_2 = lean_box(0);
 return x_2;
 }
 }
-lean_object* l_Lean_NameMap_HasEmptyc(lean_object* x_1) {
+lean_object* l_Lean_NameMap_Lean_Data_Name___instance__4(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -1388,7 +2515,7 @@ x_2 = lean_box(0);
 return x_2;
 }
 }
-lean_object* l_Lean_NameMap_Inhabited(lean_object* x_1) {
+lean_object* l_Lean_NameMap_Lean_Data_Name___instance__5(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -1396,2380 +2523,2457 @@ x_2 = lean_box(0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = l_Lean_Name_quickLt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = l_Lean_Name_quickLt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = l_Lean_Name_quickLt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = l_Lean_Name_quickLt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = l_Lean_Name_quickLt(x_2, x_17);
-if (x_20 == 0)
+x_24 = l_Lean_Name_quickLt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = l_Lean_Name_quickLt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = l_Lean_Name_quickLt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = l_Lean_Name_quickLt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = l_Lean_Name_quickLt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = l_Lean_Name_quickLt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = l_Lean_Name_quickLt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = l_Lean_Name_quickLt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = l_Lean_Name_quickLt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = l_Lean_Name_quickLt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = l_Lean_Name_quickLt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -3781,2388 +4985,2465 @@ return x_477;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = l_Lean_Name_quickLt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = l_Lean_Name_quickLt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = l_Lean_Name_quickLt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = l_Lean_Name_quickLt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = l_Lean_Name_quickLt(x_2, x_17);
-if (x_20 == 0)
+x_24 = l_Lean_Name_quickLt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = l_Lean_Name_quickLt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = l_Lean_Name_quickLt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = l_Lean_Name_quickLt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = l_Lean_Name_quickLt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = l_Lean_Name_quickLt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = l_Lean_Name_quickLt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = l_Lean_Name_quickLt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = l_Lean_Name_quickLt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = l_Lean_Name_quickLt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = l_Lean_Name_quickLt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -6174,11 +7455,11 @@ return x_477;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg), 3, 0);
 return x_2;
 }
 }
@@ -6190,13 +7471,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__2___rarg(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__2___rarg(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_NameMap_insert___spec__3___rarg(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_NameMap_insert___spec__3___rarg(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -6226,7 +7507,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_NameMap_insert___rarg), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -6269,11 +7550,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -6281,7 +7562,7 @@ uint8_t l_Lean_NameMap_contains___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1___rarg(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -6305,11 +7586,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_NameMap_contains___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_NameMap_contains___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_NameMap_contains___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -6326,7 +7607,7 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -6369,11 +7650,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -6381,7 +7662,7 @@ lean_object* l_Lean_NameMap_find_x3f___rarg(lean_object* x_1, lean_object* x_2)
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_1, x_2);
 return x_3;
 }
 }
@@ -6393,11 +7674,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_NameMap_find_x3f___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_NameMap_find_x3f___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_NameMap_find_x3f___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -6421,7 +7702,7 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_NameSet_HasEmptyc() {
+static lean_object* _init_l_Lean_NameSet_Lean_Data_Name___instance__6() {
 _start:
 {
 lean_object* x_1; 
@@ -6429,7 +7710,7 @@ x_1 = l_Lean_NameSet_empty;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_NameSet_Inhabited() {
+static lean_object* _init_l_Lean_NameSet_Lean_Data_Name___instance__7() {
 _start:
 {
 lean_object* x_1; 
@@ -6437,2380 +7718,2457 @@ x_1 = l_Lean_NameSet_empty;
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = l_Lean_Name_quickLt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = l_Lean_Name_quickLt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = l_Lean_Name_quickLt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = l_Lean_Name_quickLt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = l_Lean_Name_quickLt(x_2, x_17);
-if (x_20 == 0)
+x_24 = l_Lean_Name_quickLt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = l_Lean_Name_quickLt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = l_Lean_Name_quickLt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = l_Lean_Name_quickLt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = l_Lean_Name_quickLt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = l_Lean_Name_quickLt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = l_Lean_Name_quickLt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = l_Lean_Name_quickLt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = l_Lean_Name_quickLt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = l_Lean_Name_quickLt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = l_Lean_Name_quickLt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -8830,13 +10188,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_NameSet_insert___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_NameSet_insert___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -8851,7 +10209,7 @@ x_4 = l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(x_1, x_2, x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameSet_contains___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_NameSet_contains___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -8898,7 +10256,7 @@ uint8_t l_Lean_NameSet_contains(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_NameSet_contains___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_NameSet_contains___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 uint8_t x_4; 
@@ -8914,11 +10272,11 @@ return x_5;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_NameSet_contains___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_NameSet_contains___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_NameSet_contains___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_NameSet_contains___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -8960,7 +10318,7 @@ x_1 = l_Lean_NameHashSet_empty___closed__1;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_NameHashSet_HasEmptyc() {
+static lean_object* _init_l_Lean_NameHashSet_Lean_Data_Name___instance__8() {
 _start:
 {
 lean_object* x_1; 
@@ -8968,7 +10326,7 @@ x_1 = l_Std_HashSet_Inhabited___closed__1;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_NameHashSet_Inhabited() {
+static lean_object* _init_l_Lean_NameHashSet_Lean_Data_Name___instance__9() {
 _start:
 {
 lean_object* x_1; 
@@ -9411,26 +10769,36 @@ lean_dec_ref(res);
 res = initialize_Std_Data_RBTree(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_stringToName___closed__1 = _init_l_Lean_stringToName___closed__1();
-lean_mark_persistent(l_Lean_stringToName___closed__1);
-l_Lean_stringToName = _init_l_Lean_stringToName();
-lean_mark_persistent(l_Lean_stringToName);
+l_Lean_Lean_Data_Name___instance__1___closed__1 = _init_l_Lean_Lean_Data_Name___instance__1___closed__1();
+lean_mark_persistent(l_Lean_Lean_Data_Name___instance__1___closed__1);
+l_Lean_Lean_Data_Name___instance__1 = _init_l_Lean_Lean_Data_Name___instance__1();
+lean_mark_persistent(l_Lean_Lean_Data_Name___instance__1);
+l_Lean_Lean_Data_Name___instance__2 = _init_l_Lean_Lean_Data_Name___instance__2();
+lean_mark_persistent(l_Lean_Lean_Data_Name___instance__2);
+l_Lean_Name_getString_x21___closed__1 = _init_l_Lean_Name_getString_x21___closed__1();
+lean_mark_persistent(l_Lean_Name_getString_x21___closed__1);
+l_Lean_Name_getString_x21___closed__2 = _init_l_Lean_Name_getString_x21___closed__2();
+lean_mark_persistent(l_Lean_Name_getString_x21___closed__2);
+l_Lean_Name_getString_x21___closed__3 = _init_l_Lean_Name_getString_x21___closed__3();
+lean_mark_persistent(l_Lean_Name_getString_x21___closed__3);
+l_Lean_Name_getString_x21___closed__4 = _init_l_Lean_Name_getString_x21___closed__4();
+lean_mark_persistent(l_Lean_Name_getString_x21___closed__4);
 l_Lean_Name_hasLtQuick = _init_l_Lean_Name_hasLtQuick();
 lean_mark_persistent(l_Lean_Name_hasLtQuick);
 l_Lean_NameSet_empty = _init_l_Lean_NameSet_empty();
 lean_mark_persistent(l_Lean_NameSet_empty);
-l_Lean_NameSet_HasEmptyc = _init_l_Lean_NameSet_HasEmptyc();
-lean_mark_persistent(l_Lean_NameSet_HasEmptyc);
-l_Lean_NameSet_Inhabited = _init_l_Lean_NameSet_Inhabited();
-lean_mark_persistent(l_Lean_NameSet_Inhabited);
+l_Lean_NameSet_Lean_Data_Name___instance__6 = _init_l_Lean_NameSet_Lean_Data_Name___instance__6();
+lean_mark_persistent(l_Lean_NameSet_Lean_Data_Name___instance__6);
+l_Lean_NameSet_Lean_Data_Name___instance__7 = _init_l_Lean_NameSet_Lean_Data_Name___instance__7();
+lean_mark_persistent(l_Lean_NameSet_Lean_Data_Name___instance__7);
 l_Lean_NameHashSet_empty___closed__1 = _init_l_Lean_NameHashSet_empty___closed__1();
 lean_mark_persistent(l_Lean_NameHashSet_empty___closed__1);
 l_Lean_NameHashSet_empty = _init_l_Lean_NameHashSet_empty();
 lean_mark_persistent(l_Lean_NameHashSet_empty);
-l_Lean_NameHashSet_HasEmptyc = _init_l_Lean_NameHashSet_HasEmptyc();
-lean_mark_persistent(l_Lean_NameHashSet_HasEmptyc);
-l_Lean_NameHashSet_Inhabited = _init_l_Lean_NameHashSet_Inhabited();
-lean_mark_persistent(l_Lean_NameHashSet_Inhabited);
+l_Lean_NameHashSet_Lean_Data_Name___instance__8 = _init_l_Lean_NameHashSet_Lean_Data_Name___instance__8();
+lean_mark_persistent(l_Lean_NameHashSet_Lean_Data_Name___instance__8);
+l_Lean_NameHashSet_Lean_Data_Name___instance__9 = _init_l_Lean_NameHashSet_Lean_Data_Name___instance__9();
+lean_mark_persistent(l_Lean_NameHashSet_Lean_Data_Name___instance__9);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Data/Occurrences.c b/stage0/stdlib/Lean/Data/Occurrences.c
index d54456f491..5f759ffabb 100644
--- a/stage0/stdlib/Lean/Data/Occurrences.c
+++ b/stage0/stdlib/Lean/Data/Occurrences.c
@@ -13,21 +13,27 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Lean_Occurrences_beq_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Occurrences_isAll_match__1(lean_object*);
 lean_object* l_Lean_Occurrences_contains___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Occurrences_contains_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Occurrences_beq_match__1(lean_object*);
 uint8_t l_List_elem___main___at_Lean_Occurrences_contains___spec__1(lean_object*, lean_object*);
 uint8_t l_Lean_Occurrences_beq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
-lean_object* l_Lean_Occurrences_HasBeq;
 uint8_t l_Lean_Occurrences_contains(lean_object*, lean_object*);
 uint8_t l_List_beq___main___at_Lean_Occurrences_beq___spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_Occurrences_Lean_Data_Occurrences___instance__2;
 lean_object* l_Lean_Occurrences_beq___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Occurrences_Inhabited;
-lean_object* l_Lean_Occurrences_HasBeq___closed__1;
 lean_object* l_List_elem___main___at_Lean_Occurrences_contains___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Occurrences_Lean_Data_Occurrences___instance__2___closed__1;
+lean_object* l_Lean_Occurrences_contains_match__1(lean_object*);
+lean_object* l_Lean_Occurrences_isAll_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Occurrences_isAll___boxed(lean_object*);
 uint8_t l_Lean_Occurrences_isAll(lean_object*);
 lean_object* l_List_beq___main___at_Lean_Occurrences_beq___spec__1___boxed(lean_object*, lean_object*);
-static lean_object* _init_l_Lean_Occurrences_Inhabited() {
+lean_object* l_Lean_Occurrences_Lean_Data_Occurrences___instance__1;
+static lean_object* _init_l_Lean_Occurrences_Lean_Data_Occurrences___instance__1() {
 _start:
 {
 lean_object* x_1; 
@@ -35,6 +41,51 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
+lean_object* l_Lean_Occurrences_contains_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_6; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_6 = lean_apply_1(x_3, x_2);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_5);
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_2(x_4, x_7, x_2);
+return x_8;
+}
+default: 
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_apply_2(x_5, x_9, x_2);
+return x_10;
+}
+}
+}
+}
+lean_object* l_Lean_Occurrences_contains_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Occurrences_contains_match__1___rarg), 5, 0);
+return x_2;
+}
+}
 uint8_t l_List_elem___main___at_Lean_Occurrences_contains___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -124,6 +175,34 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
+lean_object* l_Lean_Occurrences_isAll_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; 
+lean_dec(x_2);
+x_6 = lean_apply_1(x_3, x_1);
+return x_6;
+}
+}
+}
+lean_object* l_Lean_Occurrences_isAll_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Occurrences_isAll_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Occurrences_isAll(lean_object* x_1) {
 _start:
 {
@@ -151,6 +230,91 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Occurrences_beq_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_dec(x_5);
+lean_dec(x_4);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_6);
+x_7 = lean_box(0);
+x_8 = lean_apply_1(x_3, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_3);
+x_9 = lean_apply_2(x_6, x_1, x_2);
+return x_9;
+}
+}
+case 1:
+{
+lean_dec(x_5);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 1)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_6);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_ctor_get(x_2, 0);
+lean_inc(x_11);
+lean_dec(x_2);
+x_12 = lean_apply_2(x_4, x_10, x_11);
+return x_12;
+}
+else
+{
+lean_object* x_13; 
+lean_dec(x_4);
+x_13 = lean_apply_2(x_6, x_1, x_2);
+return x_13;
+}
+}
+default: 
+{
+lean_dec(x_4);
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 2)
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_6);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+lean_dec(x_1);
+x_15 = lean_ctor_get(x_2, 0);
+lean_inc(x_15);
+lean_dec(x_2);
+x_16 = lean_apply_2(x_5, x_14, x_15);
+return x_16;
+}
+else
+{
+lean_object* x_17; 
+lean_dec(x_5);
+x_17 = lean_apply_2(x_6, x_1, x_2);
+return x_17;
+}
+}
+}
+}
+}
+lean_object* l_Lean_Occurrences_beq_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Occurrences_beq_match__1___rarg), 6, 0);
+return x_2;
+}
+}
 uint8_t l_List_beq___main___at_Lean_Occurrences_beq___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -279,7 +443,7 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_Occurrences_HasBeq___closed__1() {
+static lean_object* _init_l_Lean_Occurrences_Lean_Data_Occurrences___instance__2___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -287,11 +451,11 @@ x_1 = lean_alloc_closure((void*)(l_Lean_Occurrences_beq___boxed), 2, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Occurrences_HasBeq() {
+static lean_object* _init_l_Lean_Occurrences_Lean_Data_Occurrences___instance__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Occurrences_HasBeq___closed__1;
+x_1 = l_Lean_Occurrences_Lean_Data_Occurrences___instance__2___closed__1;
 return x_1;
 }
 }
@@ -304,12 +468,12 @@ _G_initialized = true;
 res = initialize_Init(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Occurrences_Inhabited = _init_l_Lean_Occurrences_Inhabited();
-lean_mark_persistent(l_Lean_Occurrences_Inhabited);
-l_Lean_Occurrences_HasBeq___closed__1 = _init_l_Lean_Occurrences_HasBeq___closed__1();
-lean_mark_persistent(l_Lean_Occurrences_HasBeq___closed__1);
-l_Lean_Occurrences_HasBeq = _init_l_Lean_Occurrences_HasBeq();
-lean_mark_persistent(l_Lean_Occurrences_HasBeq);
+l_Lean_Occurrences_Lean_Data_Occurrences___instance__1 = _init_l_Lean_Occurrences_Lean_Data_Occurrences___instance__1();
+lean_mark_persistent(l_Lean_Occurrences_Lean_Data_Occurrences___instance__1);
+l_Lean_Occurrences_Lean_Data_Occurrences___instance__2___closed__1 = _init_l_Lean_Occurrences_Lean_Data_Occurrences___instance__2___closed__1();
+lean_mark_persistent(l_Lean_Occurrences_Lean_Data_Occurrences___instance__2___closed__1);
+l_Lean_Occurrences_Lean_Data_Occurrences___instance__2 = _init_l_Lean_Occurrences_Lean_Data_Occurrences___instance__2();
+lean_mark_persistent(l_Lean_Occurrences_Lean_Data_Occurrences___instance__2);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Data/OpenDecl.c b/stage0/stdlib/Lean/Data/OpenDecl.c
index 590c983cae..32da1b6541 100644
--- a/stage0/stdlib/Lean/Data/OpenDecl.c
+++ b/stage0/stdlib/Lean/Data/OpenDecl.c
@@ -14,31 +14,33 @@
 extern "C" {
 #endif
 lean_object* l_Lean_rootNamespace;
+lean_object* l_List_toString___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__2(lean_object*);
 extern lean_object* l_List_repr___rarg___closed__1;
 uint8_t lean_name_eq(lean_object*, lean_object*);
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2;
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1;
 lean_object* lean_string_append(lean_object*, lean_object*);
-uint8_t l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(lean_object*, lean_object*);
 extern lean_object* l_String_splitAux___main___closed__1;
 extern lean_object* l_List_repr___rarg___closed__3;
 lean_object* l_Lean_rootNamespace___closed__1;
 lean_object* l_Lean_rootNamespace___closed__2;
-lean_object* l_Lean_OpenDecl_Inhabited___closed__1;
+lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3(uint8_t, lean_object*);
 lean_object* l_Lean_removeRoot(lean_object*);
-lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3___boxed(lean_object*, lean_object*);
-lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3(uint8_t, lean_object*);
-lean_object* l_Lean_OpenDecl_HasToString___closed__1;
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1___closed__1;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__2;
 extern lean_object* l_List_reprAux___main___rarg___closed__1;
-lean_object* l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_OpenDecl_HasToString___closed__2;
-lean_object* l_List_toString___at_Lean_OpenDecl_HasToString___spec__2(lean_object*);
-lean_object* l_Lean_OpenDecl_HasToString(lean_object*);
-lean_object* l_Lean_OpenDecl_Inhabited;
+lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2_match__1(lean_object*);
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2(lean_object*);
+lean_object* l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_System_FilePath_dirName___closed__1;
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__1;
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
-static lean_object* _init_l_Lean_OpenDecl_Inhabited___closed__1() {
+lean_object* l_Lean_Name_replacePrefix(lean_object*, lean_object*, lean_object*);
+uint8_t l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(lean_object*, lean_object*);
+static lean_object* _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -50,15 +52,52 @@ lean_ctor_set(x_3, 1, x_1);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_OpenDecl_Inhabited() {
+static lean_object* _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_OpenDecl_Inhabited___closed__1;
+x_1 = l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1___closed__1;
 return x_1;
 }
 }
-uint8_t l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+lean_dec(x_2);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_2(x_3, x_4, x_5);
+return x_6;
+}
+else
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+lean_dec(x_1);
+x_9 = lean_apply_2(x_2, x_7, x_8);
+return x_9;
+}
+}
+}
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+uint8_t l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -108,7 +147,7 @@ goto _start;
 }
 }
 }
-lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3(uint8_t x_1, lean_object* x_2) {
+lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3(uint8_t x_1, lean_object* x_2) {
 _start:
 {
 if (x_1 == 0)
@@ -132,7 +171,7 @@ x_7 = l_Lean_Name_toStringWithSep___main(x_6, x_4);
 x_8 = l_List_reprAux___main___rarg___closed__1;
 x_9 = lean_string_append(x_8, x_7);
 lean_dec(x_7);
-x_10 = l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3(x_1, x_5);
+x_10 = l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3(x_1, x_5);
 x_11 = lean_string_append(x_9, x_10);
 lean_dec(x_10);
 return x_11;
@@ -157,7 +196,7 @@ lean_dec(x_2);
 x_15 = l_System_FilePath_dirName___closed__1;
 x_16 = l_Lean_Name_toStringWithSep___main(x_15, x_13);
 x_17 = 0;
-x_18 = l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3(x_17, x_14);
+x_18 = l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3(x_17, x_14);
 x_19 = lean_string_append(x_16, x_18);
 lean_dec(x_18);
 return x_19;
@@ -165,7 +204,7 @@ return x_19;
 }
 }
 }
-lean_object* l_List_toString___at_Lean_OpenDecl_HasToString___spec__2(lean_object* x_1) {
+lean_object* l_List_toString___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__2(lean_object* x_1) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -178,7 +217,7 @@ else
 {
 uint8_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_3 = 1;
-x_4 = l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3(x_3, x_1);
+x_4 = l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3(x_3, x_1);
 x_5 = l_List_repr___rarg___closed__2;
 x_6 = lean_string_append(x_5, x_4);
 lean_dec(x_4);
@@ -188,7 +227,7 @@ return x_8;
 }
 }
 }
-static lean_object* _init_l_Lean_OpenDecl_HasToString___closed__1() {
+static lean_object* _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -196,7 +235,7 @@ x_1 = lean_mk_string(" hiding ");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_OpenDecl_HasToString___closed__2() {
+static lean_object* _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -204,7 +243,7 @@ x_1 = lean_mk_string(" → ");
 return x_1;
 }
 }
-lean_object* l_Lean_OpenDecl_HasToString(lean_object* x_1) {
+lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2(lean_object* x_1) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -218,12 +257,12 @@ lean_dec(x_1);
 x_4 = l_System_FilePath_dirName___closed__1;
 x_5 = l_Lean_Name_toStringWithSep___main(x_4, x_2);
 x_6 = lean_box(0);
-x_7 = l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(x_3, x_6);
+x_7 = l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(x_3, x_6);
 if (x_7 == 0)
 {
 lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = l_List_toString___at_Lean_OpenDecl_HasToString___spec__2(x_3);
-x_9 = l_Lean_OpenDecl_HasToString___closed__1;
+x_8 = l_List_toString___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__2(x_3);
+x_9 = l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__1;
 x_10 = lean_string_append(x_9, x_8);
 lean_dec(x_8);
 x_11 = lean_string_append(x_5, x_10);
@@ -249,7 +288,7 @@ lean_inc(x_15);
 lean_dec(x_1);
 x_16 = l_System_FilePath_dirName___closed__1;
 x_17 = l_Lean_Name_toStringWithSep___main(x_16, x_14);
-x_18 = l_Lean_OpenDecl_HasToString___closed__2;
+x_18 = l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2;
 x_19 = lean_string_append(x_17, x_18);
 x_20 = l_Lean_Name_toStringWithSep___main(x_16, x_15);
 x_21 = lean_string_append(x_19, x_20);
@@ -258,24 +297,24 @@ return x_21;
 }
 }
 }
-lean_object* l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(x_1, x_2);
+x_3 = l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
 x_3 = lean_unbox(x_1);
 lean_dec(x_1);
-x_4 = l_List_toStringAux___main___at_Lean_OpenDecl_HasToString___spec__3(x_3, x_2);
+x_4 = l_List_toStringAux___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__3(x_3, x_2);
 return x_4;
 }
 }
@@ -311,7 +350,7 @@ _start:
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_rootNamespace;
 x_3 = lean_box(0);
-x_4 = l_Lean_Name_replacePrefix___main(x_1, x_2, x_3);
+x_4 = l_Lean_Name_replacePrefix(x_1, x_2, x_3);
 return x_4;
 }
 }
@@ -328,14 +367,14 @@ lean_dec_ref(res);
 res = initialize_Lean_Data_Name(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_OpenDecl_Inhabited___closed__1 = _init_l_Lean_OpenDecl_Inhabited___closed__1();
-lean_mark_persistent(l_Lean_OpenDecl_Inhabited___closed__1);
-l_Lean_OpenDecl_Inhabited = _init_l_Lean_OpenDecl_Inhabited();
-lean_mark_persistent(l_Lean_OpenDecl_Inhabited);
-l_Lean_OpenDecl_HasToString___closed__1 = _init_l_Lean_OpenDecl_HasToString___closed__1();
-lean_mark_persistent(l_Lean_OpenDecl_HasToString___closed__1);
-l_Lean_OpenDecl_HasToString___closed__2 = _init_l_Lean_OpenDecl_HasToString___closed__2();
-lean_mark_persistent(l_Lean_OpenDecl_HasToString___closed__2);
+l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1___closed__1 = _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1___closed__1();
+lean_mark_persistent(l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1___closed__1);
+l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1 = _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1();
+lean_mark_persistent(l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__1);
+l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__1 = _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__1();
+lean_mark_persistent(l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__1);
+l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2 = _init_l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2();
+lean_mark_persistent(l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2);
 l_Lean_rootNamespace___closed__1 = _init_l_Lean_rootNamespace___closed__1();
 lean_mark_persistent(l_Lean_rootNamespace___closed__1);
 l_Lean_rootNamespace___closed__2 = _init_l_Lean_rootNamespace___closed__2();
diff --git a/stage0/stdlib/Lean/Data/Options.c b/stage0/stdlib/Lean/Data/Options.c
index 44154b36e7..683e56bcae 100644
--- a/stage0/stdlib/Lean/Data/Options.c
+++ b/stage0/stdlib/Lean/Data/Options.c
@@ -14,93 +14,109 @@
 extern "C" {
 #endif
 lean_object* l_Lean_getBoolOption___rarg(lean_object*, lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__1;
 lean_object* l_Lean_KVMap_setBool(lean_object*, lean_object*, uint8_t);
+lean_object* l_Lean_setOptionFromString_match__1(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__2;
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__2;
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1;
+lean_object* l_Lean_OptionDecl_group___default;
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1___boxed(lean_object*, lean_object*);
+uint8_t lean_name_eq(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_getOptionDecl___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__1;
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__4;
 lean_object* l_Lean_KVMap_setNat(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
-lean_object* l_Lean_verboseOption___closed__3;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_setString(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_maxMemoryOption(lean_object*);
+lean_object* l_Lean_setOptionFromString_match__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__4;
 lean_object* l_Lean_getOptionDefaulValue(lean_object*, lean_object*);
 lean_object* l_Lean_getOptionDecls(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__2;
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* l_String_toInt_x3f(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__4;
 extern lean_object* l_String_splitAux___main___closed__1;
+lean_object* l_IO_mkRef___at___private_Lean_Data_Options_0__Lean_initOptionDeclsRef___spec__1(lean_object*, lean_object*);
 lean_object* l_String_splitOn(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Options_2__optionDeclsRef;
-lean_object* l_Std_RBNode_find___main___at_Lean_getOptionDecl___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_getOptionDecl___closed__1;
 uint8_t l_Lean_NameMap_contains___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_KVMap_HasToString(lean_object*);
-lean_object* l_Lean_Options_HasToString___closed__1;
+lean_object* l_Lean_setOptionFromString_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_setOptionFromString_match__4___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getNatOption(lean_object*);
 lean_object* l_Lean_getBoolOption___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_timeoutOption___closed__4;
 lean_object* l_Lean_registerOption___closed__1;
 lean_object* l_Lean_registerOption___closed__2;
+lean_object* l_Lean_Options_Lean_Data_Options___instance__2;
+lean_object* l___private_Lean_Data_Options_0__Lean_optionDeclsRef;
 lean_object* l_String_toName(lean_object*);
 lean_object* l_Lean_setOptionFromString___closed__4;
 lean_object* l_Lean_getOptionDecl(lean_object*, lean_object*);
+lean_object* l_Lean_OptionDecl_descr___default;
 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_initFn____x40_Lean_Data_Options___hyg_481_(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_495_(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_510_(lean_object*);
+lean_object* l_Lean_setOptionFromString___closed__8;
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Options_Inhabited;
-lean_object* l_Lean_Options_HasToString;
 extern lean_object* l_Char_HasRepr___closed__1;
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* lean_get_option_decls_array(lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_getNatOption___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_setInt(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_verboseOption___closed__4;
 lean_object* l_Lean_Options_empty;
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__5;
 lean_object* l_Lean_setOptionFromString___closed__5;
 lean_object* l_Lean_getBoolOption___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_maxMemoryOption___closed__5;
 lean_object* l_Lean_KVMap_getNat(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1(lean_object*, lean_object*);
-lean_object* l_Lean_maxMemoryOption___closed__3;
+lean_object* l_Lean_getOptionDecl_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__3;
+lean_object* l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_setName(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Bool_HasRepr___closed__1;
-lean_object* l_Lean_timeoutOption___closed__2;
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__3;
+lean_object* l_Std_RBNode_find___at_Lean_getOptionDecl___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_setOptionFromString(lean_object*, lean_object*, lean_object*);
-lean_object* l_IO_mkRef___at___private_Lean_Data_Options_1__initOptionDeclsRef___spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__5;
 lean_object* l_Lean_setOptionFromString___closed__6;
+lean_object* l_Lean_Options_Lean_Data_Options___instance__2___closed__1;
+lean_object* l_Lean_registerOption___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Bool_HasRepr___closed__2;
-lean_object* l___private_Lean_Data_Options_1__initOptionDeclsRef(lean_object*);
-lean_object* l_Lean_verboseOption___closed__2;
 lean_object* l_Lean_setOptionFromString___closed__1;
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3;
+lean_object* l_Lean_setOptionFromString_match__3(lean_object*);
 lean_object* l_Lean_getBoolOption___rarg___lambda__1(lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Lean_getNatOption___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_monadOptsFromLift(lean_object*, lean_object*);
 lean_object* lean_register_option(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_verboseOption___closed__1;
-lean_object* l_Lean_timeoutOption___closed__1;
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__5;
+lean_object* l_Lean_Options_Lean_Data_Options___instance__1;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_maxMemoryOption___closed__1;
-lean_object* l_Std_RBNode_find___main___at_Lean_getOptionDecl___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_getBoolOption(lean_object*);
 lean_object* l_String_trim(lean_object*);
-lean_object* l_Lean_maxMemoryOption___closed__2;
+lean_object* l_Lean_getOptionDecl_match__1(lean_object*);
+lean_object* l_Lean_setOptionFromString_match__2(lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Options_0__Lean_initOptionDeclsRef(lean_object*);
 lean_object* l_Lean_setOptionFromString___closed__2;
 lean_object* l_String_toNat_x3f(lean_object*);
 extern lean_object* l_System_FilePath_dirName___closed__1;
-lean_object* l_Lean_timeoutOption___closed__3;
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
+lean_object* l_Lean_registerOption___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_monadOptsFromLift___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_OptionDecls_inhabited;
-lean_object* l_Lean_verboseOption___closed__5;
+lean_object* l_Lean_setOptionFromString___closed__7;
+lean_object* l_Lean_setOptionFromString_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getOptionDescr(lean_object*, lean_object*);
-lean_object* l_Lean_timeoutOption(lean_object*);
 lean_object* l_Lean_setOptionFromString___closed__3;
-lean_object* l_Lean_maxMemoryOption___closed__4;
+lean_object* l_Lean_KVMap_Lean_Data_KVMap___instance__2(lean_object*);
 lean_object* l_Lean_getNatOption___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___main___at_Lean_setOptionFromString___spec__1(lean_object*);
-uint8_t lean_string_dec_eq(lean_object*, lean_object*);
-lean_object* l_Lean_verboseOption(lean_object*);
-lean_object* l_Lean_timeoutOption___closed__5;
 static lean_object* _init_l_Lean_Options_empty() {
 _start:
 {
@@ -109,7 +125,7 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Options_Inhabited() {
+static lean_object* _init_l_Lean_Options_Lean_Data_Options___instance__1() {
 _start:
 {
 lean_object* x_1; 
@@ -117,19 +133,35 @@ x_1 = l_Lean_Options_empty;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Options_HasToString___closed__1() {
+static lean_object* _init_l_Lean_Options_Lean_Data_Options___instance__2___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_HasToString), 1, 0);
+x_1 = lean_alloc_closure((void*)(l_Lean_KVMap_Lean_Data_KVMap___instance__2), 1, 0);
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Options_HasToString() {
+static lean_object* _init_l_Lean_Options_Lean_Data_Options___instance__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Options_HasToString___closed__1;
+x_1 = l_Lean_Options_Lean_Data_Options___instance__2___closed__1;
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_OptionDecl_group___default() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_String_splitAux___main___closed__1;
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_OptionDecl_descr___default() {
+_start:
+{
+lean_object* x_1; 
+x_1 = l_String_splitAux___main___closed__1;
 return x_1;
 }
 }
@@ -141,7 +173,7 @@ x_1 = lean_box(0);
 return x_1;
 }
 }
-lean_object* l_IO_mkRef___at___private_Lean_Data_Options_1__initOptionDeclsRef___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_IO_mkRef___at___private_Lean_Data_Options_0__Lean_initOptionDeclsRef___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -166,15 +198,42 @@ return x_7;
 }
 }
 }
-lean_object* l___private_Lean_Data_Options_1__initOptionDeclsRef(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Options_0__Lean_initOptionDeclsRef(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = lean_box(0);
-x_3 = l_IO_mkRef___at___private_Lean_Data_Options_1__initOptionDeclsRef___spec__1(x_2, x_1);
+x_3 = l_IO_mkRef___at___private_Lean_Data_Options_0__Lean_initOptionDeclsRef___spec__1(x_2, x_1);
 return x_3;
 }
 }
+lean_object* l_Lean_registerOption___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_6 = l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(x_1, x_2, x_3);
+x_7 = l___private_Lean_Data_Options_0__Lean_optionDeclsRef;
+x_8 = lean_st_ref_set(x_7, x_6, x_5);
+x_9 = !lean_is_exclusive(x_8);
+if (x_9 == 0)
+{
+return x_8;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_10 = lean_ctor_get(x_8, 0);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+lean_inc(x_10);
+lean_dec(x_8);
+x_12 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_12, 0, x_10);
+lean_ctor_set(x_12, 1, x_11);
+return x_12;
+}
+}
+}
 static lean_object* _init_l_Lean_registerOption___closed__1() {
 _start:
 {
@@ -195,7 +254,7 @@ lean_object* lean_register_option(lean_object* x_1, lean_object* x_2, lean_objec
 _start:
 {
 lean_object* x_4; lean_object* x_5; uint8_t x_6; 
-x_4 = l___private_Lean_Data_Options_2__optionDeclsRef;
+x_4 = l___private_Lean_Data_Options_0__Lean_optionDeclsRef;
 x_5 = lean_st_ref_get(x_4, x_3);
 x_6 = !lean_is_exclusive(x_5);
 if (x_6 == 0)
@@ -206,110 +265,83 @@ x_8 = lean_ctor_get(x_5, 1);
 x_9 = l_Lean_NameMap_contains___rarg(x_7, x_1);
 if (x_9 == 0)
 {
-lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+lean_object* x_10; lean_object* x_11; 
 lean_free_object(x_5);
-x_10 = l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(x_7, x_1, x_2);
-x_11 = lean_st_ref_set(x_4, x_10, x_8);
-x_12 = !lean_is_exclusive(x_11);
-if (x_12 == 0)
-{
+x_10 = lean_box(0);
+x_11 = l_Lean_registerOption___lambda__1(x_7, x_1, x_2, x_10, x_8);
 return x_11;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-x_13 = lean_ctor_get(x_11, 0);
-x_14 = lean_ctor_get(x_11, 1);
-lean_inc(x_14);
-lean_inc(x_13);
-lean_dec(x_11);
-x_15 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_15, 0, x_13);
-lean_ctor_set(x_15, 1, x_14);
-return x_15;
-}
-}
-else
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
 lean_dec(x_7);
 lean_dec(x_2);
-x_16 = l_System_FilePath_dirName___closed__1;
-x_17 = l_Lean_Name_toStringWithSep___main(x_16, x_1);
-x_18 = l_Lean_registerOption___closed__1;
-x_19 = lean_string_append(x_18, x_17);
-lean_dec(x_17);
-x_20 = l_Lean_registerOption___closed__2;
-x_21 = lean_string_append(x_19, x_20);
-x_22 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_22, 0, x_21);
+x_12 = l_System_FilePath_dirName___closed__1;
+x_13 = l_Lean_Name_toStringWithSep___main(x_12, x_1);
+x_14 = l_Lean_registerOption___closed__1;
+x_15 = lean_string_append(x_14, x_13);
+lean_dec(x_13);
+x_16 = l_Lean_registerOption___closed__2;
+x_17 = lean_string_append(x_15, x_16);
+x_18 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_18, 0, x_17);
 lean_ctor_set_tag(x_5, 1);
-lean_ctor_set(x_5, 0, x_22);
+lean_ctor_set(x_5, 0, x_18);
 return x_5;
 }
 }
 else
 {
-lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_23 = lean_ctor_get(x_5, 0);
-x_24 = lean_ctor_get(x_5, 1);
-lean_inc(x_24);
-lean_inc(x_23);
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_5, 0);
+x_20 = lean_ctor_get(x_5, 1);
+lean_inc(x_20);
+lean_inc(x_19);
 lean_dec(x_5);
-x_25 = l_Lean_NameMap_contains___rarg(x_23, x_1);
-if (x_25 == 0)
+x_21 = l_Lean_NameMap_contains___rarg(x_19, x_1);
+if (x_21 == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_26 = l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(x_23, x_1, x_2);
-x_27 = lean_st_ref_set(x_4, x_26, x_24);
-x_28 = lean_ctor_get(x_27, 0);
-lean_inc(x_28);
-x_29 = lean_ctor_get(x_27, 1);
-lean_inc(x_29);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- lean_ctor_release(x_27, 1);
- x_30 = x_27;
-} else {
- lean_dec_ref(x_27);
- x_30 = lean_box(0);
-}
-if (lean_is_scalar(x_30)) {
- x_31 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_31 = x_30;
-}
-lean_ctor_set(x_31, 0, x_28);
-lean_ctor_set(x_31, 1, x_29);
-return x_31;
+lean_object* x_22; lean_object* x_23; 
+x_22 = lean_box(0);
+x_23 = l_Lean_registerOption___lambda__1(x_19, x_1, x_2, x_22, x_20);
+return x_23;
 }
 else
 {
-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_dec(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_dec(x_19);
 lean_dec(x_2);
-x_32 = l_System_FilePath_dirName___closed__1;
-x_33 = l_Lean_Name_toStringWithSep___main(x_32, x_1);
-x_34 = l_Lean_registerOption___closed__1;
-x_35 = lean_string_append(x_34, x_33);
-lean_dec(x_33);
-x_36 = l_Lean_registerOption___closed__2;
-x_37 = lean_string_append(x_35, x_36);
-x_38 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_38, 0, x_37);
-x_39 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_24);
-return x_39;
+x_24 = l_System_FilePath_dirName___closed__1;
+x_25 = l_Lean_Name_toStringWithSep___main(x_24, x_1);
+x_26 = l_Lean_registerOption___closed__1;
+x_27 = lean_string_append(x_26, x_25);
+lean_dec(x_25);
+x_28 = l_Lean_registerOption___closed__2;
+x_29 = lean_string_append(x_27, x_28);
+x_30 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_30, 0, x_29);
+x_31 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_31, 0, x_30);
+lean_ctor_set(x_31, 1, x_20);
+return x_31;
 }
 }
 }
 }
+lean_object* l_Lean_registerOption___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Lean_registerOption___lambda__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+return x_6;
+}
+}
 lean_object* l_Lean_getOptionDecls(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; uint8_t x_4; 
-x_2 = l___private_Lean_Data_Options_2__optionDeclsRef;
+x_2 = l___private_Lean_Data_Options_0__Lean_optionDeclsRef;
 x_3 = lean_st_ref_get(x_2, x_1);
 x_4 = !lean_is_exclusive(x_3);
 if (x_4 == 0)
@@ -331,7 +363,7 @@ return x_7;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -345,7 +377,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -369,7 +401,7 @@ if (x_3 == 0)
 lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_4 = lean_ctor_get(x_2, 0);
 x_5 = l_Array_empty___closed__1;
-x_6 = l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1(x_5, x_4);
+x_6 = l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1(x_5, x_4);
 lean_dec(x_4);
 lean_ctor_set(x_2, 0, x_6);
 return x_2;
@@ -383,7 +415,7 @@ lean_inc(x_8);
 lean_inc(x_7);
 lean_dec(x_2);
 x_9 = l_Array_empty___closed__1;
-x_10 = l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1(x_9, x_7);
+x_10 = l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1(x_9, x_7);
 lean_dec(x_7);
 x_11 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_11, 0, x_10);
@@ -392,16 +424,46 @@ return x_11;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_getOptionDeclsArray___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_getOptionDeclsArray___spec__1(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getOptionDecl___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_getOptionDecl_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+}
+}
+lean_object* l_Lean_getOptionDecl_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_getOptionDecl_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Std_RBNode_find___at_Lean_getOptionDecl___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -462,7 +524,7 @@ if (x_4 == 0)
 {
 lean_object* x_5; lean_object* x_6; 
 x_5 = lean_ctor_get(x_3, 0);
-x_6 = l_Std_RBNode_find___main___at_Lean_getOptionDecl___spec__1(x_5, x_1);
+x_6 = l_Std_RBNode_find___at_Lean_getOptionDecl___spec__1(x_5, x_1);
 lean_dec(x_5);
 if (lean_obj_tag(x_6) == 0)
 {
@@ -499,7 +561,7 @@ x_16 = lean_ctor_get(x_3, 1);
 lean_inc(x_16);
 lean_inc(x_15);
 lean_dec(x_3);
-x_17 = l_Std_RBNode_find___main___at_Lean_getOptionDecl___spec__1(x_15, x_1);
+x_17 = l_Std_RBNode_find___at_Lean_getOptionDecl___spec__1(x_15, x_1);
 lean_dec(x_15);
 if (lean_obj_tag(x_17) == 0)
 {
@@ -533,11 +595,11 @@ return x_27;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getOptionDecl___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_getOptionDecl___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_getOptionDecl___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_getOptionDecl___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -663,6 +725,209 @@ return x_14;
 }
 }
 }
+lean_object* l_Lean_setOptionFromString_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_setOptionFromString_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_setOptionFromString_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_setOptionFromString_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_setOptionFromString_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_setOptionFromString_match__2___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_setOptionFromString_match__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_7; lean_object* x_8; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_1(x_2, x_7);
+return x_8;
+}
+case 1:
+{
+uint8_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_9 = lean_ctor_get_uint8(x_1, 0);
+lean_dec(x_1);
+x_10 = lean_box(x_9);
+x_11 = lean_apply_1(x_3, x_10);
+return x_11;
+}
+case 2:
+{
+lean_object* x_12; lean_object* x_13; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+lean_dec(x_1);
+x_13 = lean_apply_1(x_4, x_12);
+return x_13;
+}
+case 3:
+{
+lean_object* x_14; lean_object* x_15; 
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+lean_dec(x_1);
+x_15 = lean_apply_1(x_5, x_14);
+return x_15;
+}
+default: 
+{
+lean_object* x_16; lean_object* x_17; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_16 = lean_ctor_get(x_1, 0);
+lean_inc(x_16);
+lean_dec(x_1);
+x_17 = lean_apply_1(x_6, x_16);
+return x_17;
+}
+}
+}
+}
+lean_object* l_Lean_setOptionFromString_match__3(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_setOptionFromString_match__3___rarg), 6, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_setOptionFromString_match__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 0)
+{
+lean_object* x_6; 
+lean_dec(x_2);
+x_6 = lean_apply_1(x_3, x_1);
+return x_6;
+}
+else
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_5, 1);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+lean_dec(x_1);
+x_9 = lean_ctor_get(x_5, 0);
+lean_inc(x_9);
+lean_dec(x_5);
+x_10 = lean_apply_2(x_2, x_8, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_2);
+x_11 = lean_apply_1(x_3, x_1);
+return x_11;
+}
+}
+}
+}
+}
+lean_object* l_Lean_setOptionFromString_match__4(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_setOptionFromString_match__4___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_List_map___main___at_Lean_setOptionFromString___spec__1(lean_object* x_1) {
 _start:
 {
@@ -736,12 +1001,32 @@ return x_2;
 static lean_object* _init_l_Lean_setOptionFromString___closed__4() {
 _start:
 {
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Bool_HasRepr___closed__2;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l_Lean_setOptionFromString___closed__5() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Bool_HasRepr___closed__1;
+x_3 = lean_name_mk_string(x_1, x_2);
+return x_3;
+}
+}
+static lean_object* _init_l_Lean_setOptionFromString___closed__6() {
+_start:
+{
 lean_object* x_1; 
 x_1 = lean_mk_string("invalid Bool option value '");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_setOptionFromString___closed__5() {
+static lean_object* _init_l_Lean_setOptionFromString___closed__7() {
 _start:
 {
 lean_object* x_1; 
@@ -749,7 +1034,7 @@ x_1 = lean_mk_string("invalid Nat option value '");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_setOptionFromString___closed__6() {
+static lean_object* _init_l_Lean_setOptionFromString___closed__8() {
 _start:
 {
 lean_object* x_1; 
@@ -797,365 +1082,342 @@ x_12 = lean_ctor_get(x_9, 1);
 lean_inc(x_12);
 if (lean_obj_tag(x_12) == 0)
 {
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
 x_13 = lean_ctor_get(x_6, 0);
 lean_inc(x_13);
 lean_dec(x_6);
 x_14 = lean_ctor_get(x_9, 0);
 lean_inc(x_14);
 lean_dec(x_9);
-lean_inc(x_13);
-x_15 = l_String_toName(x_13);
-x_16 = l_Lean_getOptionDefaulValue(x_15, x_3);
-if (lean_obj_tag(x_16) == 0)
+x_15 = lean_box(0);
+x_16 = lean_name_mk_string(x_15, x_13);
+lean_inc(x_16);
+x_17 = l_Lean_getOptionDefaulValue(x_16, x_3);
+if (lean_obj_tag(x_17) == 0)
 {
-lean_object* x_17; 
-x_17 = lean_ctor_get(x_16, 0);
-lean_inc(x_17);
-switch (lean_obj_tag(x_17)) {
+lean_object* x_18; 
+x_18 = lean_ctor_get(x_17, 0);
+lean_inc(x_18);
+switch (lean_obj_tag(x_18)) {
 case 0:
 {
-uint8_t x_18; 
-lean_dec(x_17);
-x_18 = !lean_is_exclusive(x_16);
-if (x_18 == 0)
+uint8_t x_19; 
+lean_dec(x_18);
+x_19 = !lean_is_exclusive(x_17);
+if (x_19 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_19 = lean_ctor_get(x_16, 0);
-lean_dec(x_19);
-x_20 = lean_box(0);
-x_21 = lean_name_mk_string(x_20, x_13);
-x_22 = l_Lean_KVMap_setString(x_1, x_21, x_14);
-lean_ctor_set(x_16, 0, x_22);
-return x_16;
+lean_object* x_20; lean_object* x_21; 
+x_20 = lean_ctor_get(x_17, 0);
+lean_dec(x_20);
+x_21 = l_Lean_KVMap_setString(x_1, x_16, x_14);
+lean_ctor_set(x_17, 0, x_21);
+return x_17;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_23 = lean_ctor_get(x_16, 1);
-lean_inc(x_23);
-lean_dec(x_16);
-x_24 = lean_box(0);
-x_25 = lean_name_mk_string(x_24, x_13);
-x_26 = l_Lean_KVMap_setString(x_1, x_25, x_14);
-x_27 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_27, 0, x_26);
-lean_ctor_set(x_27, 1, x_23);
-return x_27;
+lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+x_22 = lean_ctor_get(x_17, 1);
+lean_inc(x_22);
+lean_dec(x_17);
+x_23 = l_Lean_KVMap_setString(x_1, x_16, x_14);
+x_24 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_24, 0, x_23);
+lean_ctor_set(x_24, 1, x_22);
+return x_24;
 }
 }
 case 1:
 {
-uint8_t x_28; 
-lean_dec(x_17);
-x_28 = !lean_is_exclusive(x_16);
+uint8_t x_25; 
+lean_dec(x_18);
+x_25 = !lean_is_exclusive(x_17);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_26 = lean_ctor_get(x_17, 0);
+lean_dec(x_26);
+x_27 = l_Lean_setOptionFromString___closed__4;
+x_28 = lean_name_eq(x_16, x_27);
 if (x_28 == 0)
 {
-lean_object* x_29; lean_object* x_30; uint8_t x_31; 
-x_29 = lean_ctor_get(x_16, 0);
-lean_dec(x_29);
-x_30 = l_Bool_HasRepr___closed__2;
-x_31 = lean_string_dec_eq(x_13, x_30);
-if (x_31 == 0)
+lean_object* x_29; uint8_t x_30; 
+x_29 = l_Lean_setOptionFromString___closed__5;
+x_30 = lean_name_eq(x_16, x_29);
+if (x_30 == 0)
 {
-lean_object* x_32; uint8_t x_33; 
-x_32 = l_Bool_HasRepr___closed__1;
-x_33 = lean_string_dec_eq(x_13, x_32);
-if (x_33 == 0)
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-lean_dec(x_13);
-lean_dec(x_1);
-x_34 = l_Lean_setOptionFromString___closed__4;
-x_35 = lean_string_append(x_34, x_14);
-lean_dec(x_14);
-x_36 = l_Char_HasRepr___closed__1;
-x_37 = lean_string_append(x_35, x_36);
-x_38 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_38, 0, x_37);
-lean_ctor_set_tag(x_16, 1);
-lean_ctor_set(x_16, 0, x_38);
-return x_16;
-}
-else
-{
-lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; 
-lean_dec(x_14);
-x_39 = lean_box(0);
-x_40 = lean_name_mk_string(x_39, x_13);
-x_41 = 0;
-x_42 = l_Lean_KVMap_setBool(x_1, x_40, x_41);
-lean_ctor_set(x_16, 0, x_42);
-return x_16;
-}
-}
-else
-{
-lean_object* x_43; lean_object* x_44; uint8_t x_45; lean_object* x_46; 
-lean_dec(x_14);
-x_43 = lean_box(0);
-x_44 = lean_name_mk_string(x_43, x_13);
-x_45 = 1;
-x_46 = l_Lean_KVMap_setBool(x_1, x_44, x_45);
-lean_ctor_set(x_16, 0, x_46);
-return x_16;
-}
-}
-else
-{
-lean_object* x_47; lean_object* x_48; uint8_t x_49; 
-x_47 = lean_ctor_get(x_16, 1);
-lean_inc(x_47);
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
 lean_dec(x_16);
-x_48 = l_Bool_HasRepr___closed__2;
-x_49 = lean_string_dec_eq(x_13, x_48);
-if (x_49 == 0)
-{
-lean_object* x_50; uint8_t x_51; 
-x_50 = l_Bool_HasRepr___closed__1;
-x_51 = lean_string_dec_eq(x_13, x_50);
-if (x_51 == 0)
-{
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
-lean_dec(x_13);
 lean_dec(x_1);
-x_52 = l_Lean_setOptionFromString___closed__4;
-x_53 = lean_string_append(x_52, x_14);
+x_31 = l_Lean_setOptionFromString___closed__6;
+x_32 = lean_string_append(x_31, x_14);
 lean_dec(x_14);
-x_54 = l_Char_HasRepr___closed__1;
-x_55 = lean_string_append(x_53, x_54);
-x_56 = lean_alloc_ctor(18, 1, 0);
+x_33 = l_Char_HasRepr___closed__1;
+x_34 = lean_string_append(x_32, x_33);
+x_35 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_35, 0, x_34);
+lean_ctor_set_tag(x_17, 1);
+lean_ctor_set(x_17, 0, x_35);
+return x_17;
+}
+else
+{
+uint8_t x_36; lean_object* x_37; 
+lean_dec(x_14);
+x_36 = 0;
+x_37 = l_Lean_KVMap_setBool(x_1, x_16, x_36);
+lean_ctor_set(x_17, 0, x_37);
+return x_17;
+}
+}
+else
+{
+uint8_t x_38; lean_object* x_39; 
+lean_dec(x_14);
+x_38 = 1;
+x_39 = l_Lean_KVMap_setBool(x_1, x_16, x_38);
+lean_ctor_set(x_17, 0, x_39);
+return x_17;
+}
+}
+else
+{
+lean_object* x_40; lean_object* x_41; uint8_t x_42; 
+x_40 = lean_ctor_get(x_17, 1);
+lean_inc(x_40);
+lean_dec(x_17);
+x_41 = l_Lean_setOptionFromString___closed__4;
+x_42 = lean_name_eq(x_16, x_41);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Lean_setOptionFromString___closed__5;
+x_44 = lean_name_eq(x_16, x_43);
+if (x_44 == 0)
+{
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+lean_dec(x_16);
+lean_dec(x_1);
+x_45 = l_Lean_setOptionFromString___closed__6;
+x_46 = lean_string_append(x_45, x_14);
+lean_dec(x_14);
+x_47 = l_Char_HasRepr___closed__1;
+x_48 = lean_string_append(x_46, x_47);
+x_49 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_49, 0, x_48);
+x_50 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_50, 0, x_49);
+lean_ctor_set(x_50, 1, x_40);
+return x_50;
+}
+else
+{
+uint8_t x_51; lean_object* x_52; lean_object* x_53; 
+lean_dec(x_14);
+x_51 = 0;
+x_52 = l_Lean_KVMap_setBool(x_1, x_16, x_51);
+x_53 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_53, 0, x_52);
+lean_ctor_set(x_53, 1, x_40);
+return x_53;
+}
+}
+else
+{
+uint8_t x_54; lean_object* x_55; lean_object* x_56; 
+lean_dec(x_14);
+x_54 = 1;
+x_55 = l_Lean_KVMap_setBool(x_1, x_16, x_54);
+x_56 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_56, 0, x_55);
-x_57 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_57, 0, x_56);
-lean_ctor_set(x_57, 1, x_47);
-return x_57;
-}
-else
-{
-lean_object* x_58; lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; 
-lean_dec(x_14);
-x_58 = lean_box(0);
-x_59 = lean_name_mk_string(x_58, x_13);
-x_60 = 0;
-x_61 = l_Lean_KVMap_setBool(x_1, x_59, x_60);
-x_62 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_62, 0, x_61);
-lean_ctor_set(x_62, 1, x_47);
-return x_62;
-}
-}
-else
-{
-lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; lean_object* x_67; 
-lean_dec(x_14);
-x_63 = lean_box(0);
-x_64 = lean_name_mk_string(x_63, x_13);
-x_65 = 1;
-x_66 = l_Lean_KVMap_setBool(x_1, x_64, x_65);
-x_67 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_67, 0, x_66);
-lean_ctor_set(x_67, 1, x_47);
-return x_67;
+lean_ctor_set(x_56, 1, x_40);
+return x_56;
 }
 }
 }
 case 2:
 {
-uint8_t x_68; 
-lean_dec(x_17);
-x_68 = !lean_is_exclusive(x_16);
-if (x_68 == 0)
+uint8_t x_57; 
+lean_dec(x_18);
+x_57 = !lean_is_exclusive(x_17);
+if (x_57 == 0)
 {
-lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; 
-x_69 = lean_ctor_get(x_16, 0);
-lean_dec(x_69);
-x_70 = lean_box(0);
-x_71 = lean_name_mk_string(x_70, x_13);
-x_72 = l_String_toName(x_14);
-x_73 = l_Lean_KVMap_setName(x_1, x_71, x_72);
-lean_ctor_set(x_16, 0, x_73);
-return x_16;
+lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_58 = lean_ctor_get(x_17, 0);
+lean_dec(x_58);
+x_59 = l_String_toName(x_14);
+x_60 = l_Lean_KVMap_setName(x_1, x_16, x_59);
+lean_ctor_set(x_17, 0, x_60);
+return x_17;
 }
 else
 {
-lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
-x_74 = lean_ctor_get(x_16, 1);
-lean_inc(x_74);
-lean_dec(x_16);
-x_75 = lean_box(0);
-x_76 = lean_name_mk_string(x_75, x_13);
-x_77 = l_String_toName(x_14);
-x_78 = l_Lean_KVMap_setName(x_1, x_76, x_77);
-x_79 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_79, 0, x_78);
-lean_ctor_set(x_79, 1, x_74);
-return x_79;
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+x_61 = lean_ctor_get(x_17, 1);
+lean_inc(x_61);
+lean_dec(x_17);
+x_62 = l_String_toName(x_14);
+x_63 = l_Lean_KVMap_setName(x_1, x_16, x_62);
+x_64 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_64, 0, x_63);
+lean_ctor_set(x_64, 1, x_61);
+return x_64;
 }
 }
 case 3:
 {
-uint8_t x_80; 
-lean_dec(x_17);
-x_80 = !lean_is_exclusive(x_16);
-if (x_80 == 0)
+uint8_t x_65; 
+lean_dec(x_18);
+x_65 = !lean_is_exclusive(x_17);
+if (x_65 == 0)
 {
-lean_object* x_81; lean_object* x_82; 
-x_81 = lean_ctor_get(x_16, 0);
-lean_dec(x_81);
-x_82 = l_String_toNat_x3f(x_14);
-if (lean_obj_tag(x_82) == 0)
+lean_object* x_66; lean_object* x_67; 
+x_66 = lean_ctor_get(x_17, 0);
+lean_dec(x_66);
+x_67 = l_String_toNat_x3f(x_14);
+if (lean_obj_tag(x_67) == 0)
 {
-lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-lean_dec(x_13);
-lean_dec(x_1);
-x_83 = l_Lean_setOptionFromString___closed__5;
-x_84 = lean_string_append(x_83, x_14);
-lean_dec(x_14);
-x_85 = l_Char_HasRepr___closed__1;
-x_86 = lean_string_append(x_84, x_85);
-x_87 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_87, 0, x_86);
-lean_ctor_set_tag(x_16, 1);
-lean_ctor_set(x_16, 0, x_87);
-return x_16;
-}
-else
-{
-lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; 
-lean_dec(x_14);
-x_88 = lean_ctor_get(x_82, 0);
-lean_inc(x_88);
-lean_dec(x_82);
-x_89 = lean_box(0);
-x_90 = lean_name_mk_string(x_89, x_13);
-x_91 = l_Lean_KVMap_setNat(x_1, x_90, x_88);
-lean_ctor_set(x_16, 0, x_91);
-return x_16;
-}
-}
-else
-{
-lean_object* x_92; lean_object* x_93; 
-x_92 = lean_ctor_get(x_16, 1);
-lean_inc(x_92);
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
 lean_dec(x_16);
-x_93 = l_String_toNat_x3f(x_14);
-if (lean_obj_tag(x_93) == 0)
-{
-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_dec(x_13);
 lean_dec(x_1);
-x_94 = l_Lean_setOptionFromString___closed__5;
-x_95 = lean_string_append(x_94, x_14);
+x_68 = l_Lean_setOptionFromString___closed__7;
+x_69 = lean_string_append(x_68, x_14);
 lean_dec(x_14);
-x_96 = l_Char_HasRepr___closed__1;
-x_97 = lean_string_append(x_95, x_96);
-x_98 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_98, 0, 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_92);
-return x_99;
+x_70 = l_Char_HasRepr___closed__1;
+x_71 = lean_string_append(x_69, x_70);
+x_72 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_72, 0, x_71);
+lean_ctor_set_tag(x_17, 1);
+lean_ctor_set(x_17, 0, x_72);
+return x_17;
 }
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; 
+lean_object* x_73; lean_object* x_74; 
 lean_dec(x_14);
-x_100 = lean_ctor_get(x_93, 0);
-lean_inc(x_100);
-lean_dec(x_93);
-x_101 = lean_box(0);
-x_102 = lean_name_mk_string(x_101, x_13);
-x_103 = l_Lean_KVMap_setNat(x_1, x_102, x_100);
-x_104 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_104, 0, x_103);
-lean_ctor_set(x_104, 1, x_92);
-return x_104;
+x_73 = lean_ctor_get(x_67, 0);
+lean_inc(x_73);
+lean_dec(x_67);
+x_74 = l_Lean_KVMap_setNat(x_1, x_16, x_73);
+lean_ctor_set(x_17, 0, x_74);
+return x_17;
+}
+}
+else
+{
+lean_object* x_75; lean_object* x_76; 
+x_75 = lean_ctor_get(x_17, 1);
+lean_inc(x_75);
+lean_dec(x_17);
+x_76 = l_String_toNat_x3f(x_14);
+if (lean_obj_tag(x_76) == 0)
+{
+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_dec(x_16);
+lean_dec(x_1);
+x_77 = l_Lean_setOptionFromString___closed__7;
+x_78 = lean_string_append(x_77, x_14);
+lean_dec(x_14);
+x_79 = l_Char_HasRepr___closed__1;
+x_80 = lean_string_append(x_78, x_79);
+x_81 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_81, 0, x_80);
+x_82 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_82, 0, x_81);
+lean_ctor_set(x_82, 1, x_75);
+return x_82;
+}
+else
+{
+lean_object* x_83; lean_object* x_84; lean_object* x_85; 
+lean_dec(x_14);
+x_83 = lean_ctor_get(x_76, 0);
+lean_inc(x_83);
+lean_dec(x_76);
+x_84 = l_Lean_KVMap_setNat(x_1, x_16, x_83);
+x_85 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_85, 0, x_84);
+lean_ctor_set(x_85, 1, x_75);
+return x_85;
 }
 }
 }
 default: 
 {
-uint8_t x_105; 
+uint8_t x_86; 
+lean_dec(x_18);
+x_86 = !lean_is_exclusive(x_17);
+if (x_86 == 0)
+{
+lean_object* x_87; lean_object* x_88; 
+x_87 = lean_ctor_get(x_17, 0);
+lean_dec(x_87);
+lean_inc(x_14);
+x_88 = l_String_toInt_x3f(x_14);
+if (lean_obj_tag(x_88) == 0)
+{
+lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; 
+lean_dec(x_16);
+lean_dec(x_1);
+x_89 = l_Lean_setOptionFromString___closed__8;
+x_90 = lean_string_append(x_89, x_14);
+lean_dec(x_14);
+x_91 = l_Char_HasRepr___closed__1;
+x_92 = lean_string_append(x_90, x_91);
+x_93 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_93, 0, x_92);
+lean_ctor_set_tag(x_17, 1);
+lean_ctor_set(x_17, 0, x_93);
+return x_17;
+}
+else
+{
+lean_object* x_94; lean_object* x_95; 
+lean_dec(x_14);
+x_94 = lean_ctor_get(x_88, 0);
+lean_inc(x_94);
+lean_dec(x_88);
+x_95 = l_Lean_KVMap_setInt(x_1, x_16, x_94);
+lean_ctor_set(x_17, 0, x_95);
+return x_17;
+}
+}
+else
+{
+lean_object* x_96; lean_object* x_97; 
+x_96 = lean_ctor_get(x_17, 1);
+lean_inc(x_96);
 lean_dec(x_17);
-x_105 = !lean_is_exclusive(x_16);
-if (x_105 == 0)
-{
-lean_object* x_106; lean_object* x_107; 
-x_106 = lean_ctor_get(x_16, 0);
-lean_dec(x_106);
 lean_inc(x_14);
-x_107 = l_String_toInt_x3f(x_14);
-if (lean_obj_tag(x_107) == 0)
+x_97 = l_String_toInt_x3f(x_14);
+if (lean_obj_tag(x_97) == 0)
 {
-lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
-lean_dec(x_13);
-lean_dec(x_1);
-x_108 = l_Lean_setOptionFromString___closed__6;
-x_109 = lean_string_append(x_108, x_14);
-lean_dec(x_14);
-x_110 = l_Char_HasRepr___closed__1;
-x_111 = lean_string_append(x_109, x_110);
-x_112 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_112, 0, x_111);
-lean_ctor_set_tag(x_16, 1);
-lean_ctor_set(x_16, 0, x_112);
-return x_16;
-}
-else
-{
-lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; 
-lean_dec(x_14);
-x_113 = lean_ctor_get(x_107, 0);
-lean_inc(x_113);
-lean_dec(x_107);
-x_114 = lean_box(0);
-x_115 = lean_name_mk_string(x_114, x_13);
-x_116 = l_Lean_KVMap_setInt(x_1, x_115, x_113);
-lean_ctor_set(x_16, 0, x_116);
-return x_16;
-}
-}
-else
-{
-lean_object* x_117; lean_object* x_118; 
-x_117 = lean_ctor_get(x_16, 1);
-lean_inc(x_117);
+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_dec(x_16);
-lean_inc(x_14);
-x_118 = l_String_toInt_x3f(x_14);
-if (lean_obj_tag(x_118) == 0)
-{
-lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; 
-lean_dec(x_13);
 lean_dec(x_1);
-x_119 = l_Lean_setOptionFromString___closed__6;
-x_120 = lean_string_append(x_119, x_14);
+x_98 = l_Lean_setOptionFromString___closed__8;
+x_99 = lean_string_append(x_98, x_14);
 lean_dec(x_14);
-x_121 = l_Char_HasRepr___closed__1;
-x_122 = lean_string_append(x_120, x_121);
-x_123 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_123, 0, x_122);
-x_124 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_124, 0, x_123);
-lean_ctor_set(x_124, 1, x_117);
-return x_124;
+x_100 = l_Char_HasRepr___closed__1;
+x_101 = lean_string_append(x_99, x_100);
+x_102 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_102, 0, x_101);
+x_103 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_103, 0, x_102);
+lean_ctor_set(x_103, 1, x_96);
+return x_103;
 }
 else
 {
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; 
+lean_object* x_104; lean_object* x_105; lean_object* x_106; 
 lean_dec(x_14);
-x_125 = lean_ctor_get(x_118, 0);
-lean_inc(x_125);
-lean_dec(x_118);
-x_126 = lean_box(0);
-x_127 = lean_name_mk_string(x_126, x_13);
-x_128 = l_Lean_KVMap_setInt(x_1, x_127, x_125);
-x_129 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_129, 0, x_128);
-lean_ctor_set(x_129, 1, x_117);
-return x_129;
+x_104 = lean_ctor_get(x_97, 0);
+lean_inc(x_104);
+lean_dec(x_97);
+x_105 = l_Lean_KVMap_setInt(x_1, x_16, x_104);
+x_106 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_106, 0, x_105);
+lean_ctor_set(x_106, 1, x_96);
+return x_106;
 }
 }
 }
@@ -1163,48 +1425,48 @@ return x_129;
 }
 else
 {
-uint8_t x_130; 
-lean_dec(x_14);
-lean_dec(x_13);
-lean_dec(x_1);
-x_130 = !lean_is_exclusive(x_16);
-if (x_130 == 0)
-{
-return x_16;
-}
-else
-{
-lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_131 = lean_ctor_get(x_16, 0);
-x_132 = lean_ctor_get(x_16, 1);
-lean_inc(x_132);
-lean_inc(x_131);
+uint8_t x_107; 
 lean_dec(x_16);
-x_133 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_133, 0, x_131);
-lean_ctor_set(x_133, 1, x_132);
-return x_133;
+lean_dec(x_14);
+lean_dec(x_1);
+x_107 = !lean_is_exclusive(x_17);
+if (x_107 == 0)
+{
+return x_17;
+}
+else
+{
+lean_object* x_108; lean_object* x_109; lean_object* x_110; 
+x_108 = lean_ctor_get(x_17, 0);
+x_109 = lean_ctor_get(x_17, 1);
+lean_inc(x_109);
+lean_inc(x_108);
+lean_dec(x_17);
+x_110 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_110, 0, x_108);
+lean_ctor_set(x_110, 1, x_109);
+return x_110;
 }
 }
 }
 else
 {
-lean_object* x_134; lean_object* x_135; 
+lean_object* x_111; lean_object* x_112; 
 lean_dec(x_12);
 lean_dec(x_9);
 lean_dec(x_6);
 lean_dec(x_1);
-x_134 = l_Lean_setOptionFromString___closed__3;
-x_135 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_135, 0, x_134);
-lean_ctor_set(x_135, 1, x_3);
-return x_135;
+x_111 = l_Lean_setOptionFromString___closed__3;
+x_112 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_112, 0, x_111);
+lean_ctor_set(x_112, 1, x_3);
+return x_112;
 }
 }
 }
 }
 }
-static lean_object* _init_l_Lean_verboseOption___closed__1() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1212,17 +1474,17 @@ x_1 = lean_mk_string("verbose");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_verboseOption___closed__2() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_verboseOption___closed__1;
+x_2 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_verboseOption___closed__3() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3() {
 _start:
 {
 uint8_t x_1; lean_object* x_2; 
@@ -1232,7 +1494,7 @@ lean_ctor_set_uint8(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_verboseOption___closed__4() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -1240,13 +1502,13 @@ x_1 = lean_mk_string("disable/enable verbose messages");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_verboseOption___closed__5() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_verboseOption___closed__3;
+x_1 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3;
 x_2 = l_String_splitAux___main___closed__1;
-x_3 = l_Lean_verboseOption___closed__4;
+x_3 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__4;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -1254,17 +1516,17 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_verboseOption(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_verboseOption___closed__2;
-x_3 = l_Lean_verboseOption___closed__5;
+x_2 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__2;
+x_3 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__5;
 x_4 = lean_register_option(x_2, x_3, x_1);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_timeoutOption___closed__1() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1272,17 +1534,17 @@ x_1 = lean_mk_string("timeout");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_timeoutOption___closed__2() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_timeoutOption___closed__1;
+x_2 = l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_timeoutOption___closed__3() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -1292,7 +1554,7 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_timeoutOption___closed__4() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -1300,13 +1562,13 @@ x_1 = lean_mk_string("the (deterministic) timeout is measured as the maximum of
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_timeoutOption___closed__5() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_timeoutOption___closed__3;
+x_1 = l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__3;
 x_2 = l_String_splitAux___main___closed__1;
-x_3 = l_Lean_timeoutOption___closed__4;
+x_3 = l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__4;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -1314,17 +1576,17 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_timeoutOption(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_495_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_timeoutOption___closed__2;
-x_3 = l_Lean_timeoutOption___closed__5;
+x_2 = l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__2;
+x_3 = l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__5;
 x_4 = lean_register_option(x_2, x_3, x_1);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_maxMemoryOption___closed__1() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1332,17 +1594,17 @@ x_1 = lean_mk_string("maxMemory");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_maxMemoryOption___closed__2() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_maxMemoryOption___closed__1;
+x_2 = l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_maxMemoryOption___closed__3() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -1352,7 +1614,7 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_maxMemoryOption___closed__4() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__4() {
 _start:
 {
 lean_object* x_1; 
@@ -1360,13 +1622,13 @@ x_1 = lean_mk_string("maximum amount of memory available for Lean in megabytes")
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_maxMemoryOption___closed__5() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_maxMemoryOption___closed__3;
+x_1 = l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__3;
 x_2 = l_String_splitAux___main___closed__1;
-x_3 = l_Lean_maxMemoryOption___closed__4;
+x_3 = l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__4;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -1374,12 +1636,12 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_maxMemoryOption(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_510_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_2 = l_Lean_maxMemoryOption___closed__2;
-x_3 = l_Lean_maxMemoryOption___closed__5;
+x_2 = l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__2;
+x_3 = l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__5;
 x_4 = lean_register_option(x_2, x_3, x_1);
 return x_4;
 }
@@ -1524,18 +1786,22 @@ if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 l_Lean_Options_empty = _init_l_Lean_Options_empty();
 lean_mark_persistent(l_Lean_Options_empty);
-l_Lean_Options_Inhabited = _init_l_Lean_Options_Inhabited();
-lean_mark_persistent(l_Lean_Options_Inhabited);
-l_Lean_Options_HasToString___closed__1 = _init_l_Lean_Options_HasToString___closed__1();
-lean_mark_persistent(l_Lean_Options_HasToString___closed__1);
-l_Lean_Options_HasToString = _init_l_Lean_Options_HasToString();
-lean_mark_persistent(l_Lean_Options_HasToString);
+l_Lean_Options_Lean_Data_Options___instance__1 = _init_l_Lean_Options_Lean_Data_Options___instance__1();
+lean_mark_persistent(l_Lean_Options_Lean_Data_Options___instance__1);
+l_Lean_Options_Lean_Data_Options___instance__2___closed__1 = _init_l_Lean_Options_Lean_Data_Options___instance__2___closed__1();
+lean_mark_persistent(l_Lean_Options_Lean_Data_Options___instance__2___closed__1);
+l_Lean_Options_Lean_Data_Options___instance__2 = _init_l_Lean_Options_Lean_Data_Options___instance__2();
+lean_mark_persistent(l_Lean_Options_Lean_Data_Options___instance__2);
+l_Lean_OptionDecl_group___default = _init_l_Lean_OptionDecl_group___default();
+lean_mark_persistent(l_Lean_OptionDecl_group___default);
+l_Lean_OptionDecl_descr___default = _init_l_Lean_OptionDecl_descr___default();
+lean_mark_persistent(l_Lean_OptionDecl_descr___default);
 l_Lean_OptionDecls_inhabited = _init_l_Lean_OptionDecls_inhabited();
 lean_mark_persistent(l_Lean_OptionDecls_inhabited);
-res = l___private_Lean_Data_Options_1__initOptionDeclsRef(lean_io_mk_world());
+res = l___private_Lean_Data_Options_0__Lean_initOptionDeclsRef(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
-l___private_Lean_Data_Options_2__optionDeclsRef = lean_io_result_get_value(res);
-lean_mark_persistent(l___private_Lean_Data_Options_2__optionDeclsRef);
+l___private_Lean_Data_Options_0__Lean_optionDeclsRef = lean_io_result_get_value(res);
+lean_mark_persistent(l___private_Lean_Data_Options_0__Lean_optionDeclsRef);
 lean_dec_ref(res);
 l_Lean_registerOption___closed__1 = _init_l_Lean_registerOption___closed__1();
 lean_mark_persistent(l_Lean_registerOption___closed__1);
@@ -1555,43 +1821,47 @@ l_Lean_setOptionFromString___closed__5 = _init_l_Lean_setOptionFromString___clos
 lean_mark_persistent(l_Lean_setOptionFromString___closed__5);
 l_Lean_setOptionFromString___closed__6 = _init_l_Lean_setOptionFromString___closed__6();
 lean_mark_persistent(l_Lean_setOptionFromString___closed__6);
-l_Lean_verboseOption___closed__1 = _init_l_Lean_verboseOption___closed__1();
-lean_mark_persistent(l_Lean_verboseOption___closed__1);
-l_Lean_verboseOption___closed__2 = _init_l_Lean_verboseOption___closed__2();
-lean_mark_persistent(l_Lean_verboseOption___closed__2);
-l_Lean_verboseOption___closed__3 = _init_l_Lean_verboseOption___closed__3();
-lean_mark_persistent(l_Lean_verboseOption___closed__3);
-l_Lean_verboseOption___closed__4 = _init_l_Lean_verboseOption___closed__4();
-lean_mark_persistent(l_Lean_verboseOption___closed__4);
-l_Lean_verboseOption___closed__5 = _init_l_Lean_verboseOption___closed__5();
-lean_mark_persistent(l_Lean_verboseOption___closed__5);
-res = l_Lean_verboseOption(lean_io_mk_world());
+l_Lean_setOptionFromString___closed__7 = _init_l_Lean_setOptionFromString___closed__7();
+lean_mark_persistent(l_Lean_setOptionFromString___closed__7);
+l_Lean_setOptionFromString___closed__8 = _init_l_Lean_setOptionFromString___closed__8();
+lean_mark_persistent(l_Lean_setOptionFromString___closed__8);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__1);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__2 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__2();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__2);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__4 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__4();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__4);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__5 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__5();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__5);
+res = l_Lean_initFn____x40_Lean_Data_Options___hyg_481_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_timeoutOption___closed__1 = _init_l_Lean_timeoutOption___closed__1();
-lean_mark_persistent(l_Lean_timeoutOption___closed__1);
-l_Lean_timeoutOption___closed__2 = _init_l_Lean_timeoutOption___closed__2();
-lean_mark_persistent(l_Lean_timeoutOption___closed__2);
-l_Lean_timeoutOption___closed__3 = _init_l_Lean_timeoutOption___closed__3();
-lean_mark_persistent(l_Lean_timeoutOption___closed__3);
-l_Lean_timeoutOption___closed__4 = _init_l_Lean_timeoutOption___closed__4();
-lean_mark_persistent(l_Lean_timeoutOption___closed__4);
-l_Lean_timeoutOption___closed__5 = _init_l_Lean_timeoutOption___closed__5();
-lean_mark_persistent(l_Lean_timeoutOption___closed__5);
-res = l_Lean_timeoutOption(lean_io_mk_world());
+l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__1 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__1();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__1);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__2 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__2();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__2);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__3 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__3();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__3);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__4 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__4();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__4);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__5 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__5();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_495____closed__5);
+res = l_Lean_initFn____x40_Lean_Data_Options___hyg_495_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_maxMemoryOption___closed__1 = _init_l_Lean_maxMemoryOption___closed__1();
-lean_mark_persistent(l_Lean_maxMemoryOption___closed__1);
-l_Lean_maxMemoryOption___closed__2 = _init_l_Lean_maxMemoryOption___closed__2();
-lean_mark_persistent(l_Lean_maxMemoryOption___closed__2);
-l_Lean_maxMemoryOption___closed__3 = _init_l_Lean_maxMemoryOption___closed__3();
-lean_mark_persistent(l_Lean_maxMemoryOption___closed__3);
-l_Lean_maxMemoryOption___closed__4 = _init_l_Lean_maxMemoryOption___closed__4();
-lean_mark_persistent(l_Lean_maxMemoryOption___closed__4);
-l_Lean_maxMemoryOption___closed__5 = _init_l_Lean_maxMemoryOption___closed__5();
-lean_mark_persistent(l_Lean_maxMemoryOption___closed__5);
-res = l_Lean_maxMemoryOption(lean_io_mk_world());
+l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__1 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__1();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__1);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__2 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__2();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__2);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__3 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__3();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__3);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__4 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__4();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__4);
+l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__5 = _init_l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__5();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Data_Options___hyg_510____closed__5);
+res = l_Lean_initFn____x40_Lean_Data_Options___hyg_510_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));
diff --git a/stage0/stdlib/Lean/Data/Position.c b/stage0/stdlib/Lean/Data/Position.c
index c647128a41..4074ce3b7c 100644
--- a/stage0/stdlib/Lean/Data/Position.c
+++ b/stage0/stdlib/Lean/Data/Position.c
@@ -13,66 +13,115 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
+lean_object* l_Lean_FileMap_toPosition_match__1(lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__2___rarg(lean_object*, lean_object*);
 lean_object* lean_nat_div(lean_object*, lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__4;
+lean_object* l_Lean_FileMap_ofString_loop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_ofString___closed__2;
-lean_object* l_Lean_Position_Inhabited;
-lean_object* l_Lean_Position_HasToString(lean_object*);
 extern lean_object* l_Array_empty___closed__1;
 extern lean_object* l_Sigma_HasRepr___rarg___closed__1;
 lean_object* l_Nat_decLt___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Position_Inhabited___closed__1;
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Position_1__ofStringAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_prodHasDecidableLt___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_formatKVMap___closed__1;
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_String_splitAux___main___closed__1;
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_ofString___closed__1;
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2_match__1___rarg(lean_object*, lean_object*);
 extern lean_object* l_Sigma_HasRepr___rarg___closed__2;
 lean_object* l_Lean_Position_lt(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Position_2__toColumnAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_utf8_next(lean_object*, lean_object*);
+lean_object* l_Lean_FileMap_Lean_Data_Position___instance__5;
+lean_object* l_Lean_FileMap_toPosition_toColumn(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
-lean_object* l_Lean_Position_Lean_HasFormat(lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2(lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Array_back___at_Lean_FileMap_toPosition___spec__1___boxed(lean_object*);
-lean_object* l___private_Lean_Data_Position_3__toPositionAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2_match__1(lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Position_2__toColumnAux___main(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Position_2__toColumnAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_FileMap_toPosition_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Nat_repr(lean_object*);
-lean_object* l___private_Lean_Data_Position_1__ofStringAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_List_reprAux___main___rarg___closed__1;
+lean_object* l_Lean_Position_Lean_Data_Position___instance__3_match__1(lean_object*);
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Position_2__toColumnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_toPosition(lean_object*, lean_object*);
+lean_object* l_Lean_FileMap_toPosition_loop___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_ofString(lean_object*);
-lean_object* l_Lean_Position_Lean_HasFormat___closed__2;
-lean_object* l_Lean_FileMap_Inhabited;
-lean_object* l___private_Lean_Data_Position_3__toPositionAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_FileMap_toPosition_toColumn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_FileMap_toPosition_loop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_UInt32_decEq(uint32_t, uint32_t);
-lean_object* l_Lean_Position_Lean_HasFormat___closed__1;
+uint8_t l_Lean_Position_Lean_Data_Position___instance__1(lean_object*, lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2___closed__1;
 lean_object* l_Array_back___at_Lean_FileMap_toPosition___spec__1(lean_object*);
-lean_object* l_Lean_Position_DecidableEq___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_FileMap_Inhabited___closed__1;
-lean_object* l___private_Lean_Data_Position_3__toPositionAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__3_match__1___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__3(lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2___closed__2;
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__1(lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__4___closed__1;
 lean_object* l_Lean_Position_lt___closed__1;
-uint8_t l_Lean_Position_DecidableEq(lean_object*, lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__2(lean_object*);
+lean_object* l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1;
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
-lean_object* l___private_Lean_Data_Position_3__toPositionAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Nat_Inhabited;
 uint8_t lean_string_utf8_at_end(lean_object*, lean_object*);
 lean_object* l_Lean_Position_lt___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_FileMap_toPosition___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Position_lt___closed__2;
+lean_object* l_Lean_Position_lt_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_decEq___boxed(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
 lean_object* l_String_toFileMap(lean_object*);
-uint8_t l_Lean_Position_DecidableEq(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Position_lt_match__1(lean_object*);
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_apply_2(x_2, x_3, x_4);
+return x_5;
+}
+}
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Position_Lean_Data_Position___instance__1_match__1___rarg), 2, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__2___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_apply_2(x_2, x_3, x_4);
+return x_5;
+}
+}
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Position_Lean_Data_Position___instance__1_match__2___rarg), 2, 0);
+return x_2;
+}
+}
+uint8_t l_Lean_Position_Lean_Data_Position___instance__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
@@ -95,17 +144,43 @@ return x_9;
 }
 }
 }
-lean_object* l_Lean_Position_DecidableEq___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Position_Lean_Data_Position___instance__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l_Lean_Position_DecidableEq(x_1, x_2);
+x_3 = l_Lean_Position_Lean_Data_Position___instance__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
 }
+lean_object* l_Lean_Position_lt_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_2, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_2, 1);
+lean_inc(x_7);
+lean_dec(x_2);
+x_8 = lean_apply_4(x_3, x_4, x_5, x_6, x_7);
+return x_8;
+}
+}
+lean_object* l_Lean_Position_lt_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Position_lt_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 static lean_object* _init_l_Lean_Position_lt___closed__1() {
 _start:
 {
@@ -156,7 +231,28 @@ lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object* x_1) {
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_apply_2(x_2, x_3, x_4);
+return x_5;
+}
+}
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Position_Lean_Data_Position___instance__2_match__1___rarg), 2, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
@@ -166,7 +262,7 @@ lean_ctor_set(x_3, 0, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Position_Lean_HasFormat___closed__1() {
+static lean_object* _init_l_Lean_Position_Lean_Data_Position___instance__2___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -176,7 +272,7 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Position_Lean_HasFormat___closed__2() {
+static lean_object* _init_l_Lean_Position_Lean_Data_Position___instance__2___closed__2() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -186,7 +282,7 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Position_Lean_HasFormat(lean_object* x_1) {
+lean_object* l_Lean_Position_Lean_Data_Position___instance__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
@@ -195,8 +291,8 @@ lean_inc(x_2);
 x_3 = lean_ctor_get(x_1, 1);
 lean_inc(x_3);
 lean_dec(x_1);
-x_4 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_2);
-x_5 = l_Lean_Position_Lean_HasFormat___closed__1;
+x_4 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_2);
+x_5 = l_Lean_Position_Lean_Data_Position___instance__2___closed__1;
 x_6 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_6, 0, x_5);
 lean_ctor_set(x_6, 1, x_4);
@@ -204,18 +300,39 @@ x_7 = l_Lean_formatKVMap___closed__1;
 x_8 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_8, 0, x_6);
 lean_ctor_set(x_8, 1, x_7);
-x_9 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_3);
+x_9 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_3);
 x_10 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_10, 0, x_8);
 lean_ctor_set(x_10, 1, x_9);
-x_11 = l_Lean_Position_Lean_HasFormat___closed__2;
+x_11 = l_Lean_Position_Lean_Data_Position___instance__2___closed__2;
 x_12 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_12, 0, x_10);
 lean_ctor_set(x_12, 1, x_11);
 return x_12;
 }
 }
-lean_object* l_Lean_Position_HasToString(lean_object* x_1) {
+lean_object* l_Lean_Position_Lean_Data_Position___instance__3_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_apply_2(x_2, x_3, x_4);
+return x_5;
+}
+}
+lean_object* l_Lean_Position_Lean_Data_Position___instance__3_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Position_Lean_Data_Position___instance__3_match__1___rarg), 2, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Position_Lean_Data_Position___instance__3(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
@@ -238,7 +355,7 @@ x_12 = lean_string_append(x_10, x_11);
 return x_12;
 }
 }
-static lean_object* _init_l_Lean_Position_Inhabited___closed__1() {
+static lean_object* _init_l_Lean_Position_Lean_Data_Position___instance__4___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -250,15 +367,15 @@ lean_ctor_set(x_3, 1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Position_Inhabited() {
+static lean_object* _init_l_Lean_Position_Lean_Data_Position___instance__4() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Position_Inhabited___closed__1;
+x_1 = l_Lean_Position_Lean_Data_Position___instance__4___closed__1;
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_FileMap_Inhabited___closed__1() {
+static lean_object* _init_l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -271,15 +388,15 @@ lean_ctor_set(x_3, 2, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_FileMap_Inhabited() {
+static lean_object* _init_l_Lean_FileMap_Lean_Data_Position___instance__5() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_FileMap_Inhabited___closed__1;
+x_1 = l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1;
 return x_1;
 }
 }
-lean_object* l___private_Lean_Data_Position_1__ofStringAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_FileMap_ofString_loop(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 uint8_t x_6; 
@@ -327,14 +444,6 @@ return x_19;
 }
 }
 }
-lean_object* l___private_Lean_Data_Position_1__ofStringAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
-_start:
-{
-lean_object* x_6; 
-x_6 = l___private_Lean_Data_Position_1__ofStringAux___main(x_1, x_2, x_3, x_4, x_5);
-return x_6;
-}
-}
 static lean_object* _init_l_Lean_FileMap_ofString___closed__1() {
 _start:
 {
@@ -363,23 +472,46 @@ x_2 = lean_unsigned_to_nat(0u);
 x_3 = lean_unsigned_to_nat(1u);
 x_4 = l_Lean_FileMap_ofString___closed__1;
 x_5 = l_Lean_FileMap_ofString___closed__2;
-x_6 = l___private_Lean_Data_Position_1__ofStringAux___main(x_1, x_2, x_3, x_4, x_5);
+x_6 = l_Lean_FileMap_ofString_loop(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
 }
-lean_object* l___private_Lean_Data_Position_2__toColumnAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_FileMap_toPosition_match__1___rarg(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; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 2);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_3(x_2, x_3, x_4, x_5);
+return x_6;
+}
+}
+lean_object* l_Lean_FileMap_toPosition_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_FileMap_toPosition_match__1___rarg), 2, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_FileMap_toPosition_toColumn(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_3, x_2);
+x_5 = lean_nat_dec_eq(x_3, x_1);
 if (x_5 == 0)
 {
 uint8_t x_6; 
-x_6 = lean_string_utf8_at_end(x_1, x_3);
+x_6 = lean_string_utf8_at_end(x_2, x_3);
 if (x_6 == 0)
 {
 lean_object* x_7; lean_object* x_8; lean_object* x_9; 
-x_7 = lean_string_utf8_next(x_1, x_3);
+x_7 = lean_string_utf8_next(x_2, x_3);
 lean_dec(x_3);
 x_8 = lean_unsigned_to_nat(1u);
 x_9 = lean_nat_add(x_4, x_8);
@@ -401,40 +533,22 @@ return x_4;
 }
 }
 }
-lean_object* l___private_Lean_Data_Position_2__toColumnAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_FileMap_toPosition_toColumn___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l___private_Lean_Data_Position_2__toColumnAux___main(x_1, x_2, x_3, x_4);
+x_5 = l_Lean_FileMap_toPosition_toColumn(x_1, x_2, x_3, x_4);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l___private_Lean_Data_Position_2__toColumnAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l___private_Lean_Data_Position_2__toColumnAux___main(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
-lean_object* l___private_Lean_Data_Position_2__toColumnAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l___private_Lean_Data_Position_2__toColumnAux(x_1, x_2, x_3, x_4);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_5;
-}
-}
-lean_object* l___private_Lean_Data_Position_3__toPositionAux___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_FileMap_toPosition_loop(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; 
 x_7 = l_Nat_Inhabited;
-x_8 = lean_array_get(x_7, x_2, x_5);
+x_8 = lean_array_get(x_7, x_3, x_5);
 x_9 = lean_unsigned_to_nat(1u);
 x_10 = lean_nat_add(x_5, x_9);
 x_11 = lean_nat_dec_eq(x_6, x_10);
@@ -447,12 +561,12 @@ x_12 = lean_nat_add(x_5, x_6);
 x_13 = lean_unsigned_to_nat(2u);
 x_14 = lean_nat_div(x_12, x_13);
 lean_dec(x_12);
-x_15 = lean_array_get(x_7, x_2, x_14);
-x_16 = lean_nat_dec_eq(x_4, x_15);
+x_15 = lean_array_get(x_7, x_3, x_14);
+x_16 = lean_nat_dec_eq(x_1, x_15);
 if (x_16 == 0)
 {
 uint8_t x_17; 
-x_17 = lean_nat_dec_lt(x_15, x_4);
+x_17 = lean_nat_dec_lt(x_15, x_1);
 lean_dec(x_15);
 if (x_17 == 0)
 {
@@ -473,7 +587,7 @@ lean_object* x_20; lean_object* x_21; lean_object* x_22;
 lean_dec(x_15);
 lean_dec(x_6);
 lean_dec(x_5);
-x_20 = lean_array_get(x_7, x_3, x_14);
+x_20 = lean_array_get(x_7, x_4, x_14);
 lean_dec(x_14);
 x_21 = lean_unsigned_to_nat(0u);
 x_22 = lean_alloc_ctor(0, 2, 0);
@@ -486,10 +600,10 @@ else
 {
 lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
 lean_dec(x_6);
-x_23 = lean_array_get(x_7, x_3, x_5);
+x_23 = lean_array_get(x_7, x_4, x_5);
 lean_dec(x_5);
 x_24 = lean_unsigned_to_nat(0u);
-x_25 = l___private_Lean_Data_Position_2__toColumnAux___main(x_1, x_4, x_8, x_24);
+x_25 = l_Lean_FileMap_toPosition_toColumn(x_1, x_2, x_8, x_24);
 x_26 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_26, 0, x_23);
 lean_ctor_set(x_26, 1, x_25);
@@ -497,31 +611,11 @@ return x_26;
 }
 }
 }
-lean_object* l___private_Lean_Data_Position_3__toPositionAux___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Lean_FileMap_toPosition_loop___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l___private_Lean_Data_Position_3__toPositionAux___main(x_1, x_2, x_3, x_4, x_5, x_6);
-lean_dec(x_4);
-lean_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-return x_7;
-}
-}
-lean_object* l___private_Lean_Data_Position_3__toPositionAux(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-lean_object* x_7; 
-x_7 = l___private_Lean_Data_Position_3__toPositionAux___main(x_1, x_2, x_3, x_4, x_5, x_6);
-return x_7;
-}
-}
-lean_object* l___private_Lean_Data_Position_3__toPositionAux___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-lean_object* x_7; 
-x_7 = l___private_Lean_Data_Position_3__toPositionAux(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Lean_FileMap_toPosition_loop(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
@@ -586,7 +680,7 @@ x_15 = lean_unsigned_to_nat(1u);
 x_16 = lean_nat_sub(x_6, x_15);
 lean_dec(x_6);
 x_17 = lean_unsigned_to_nat(0u);
-x_18 = l___private_Lean_Data_Position_3__toPositionAux___main(x_3, x_4, x_5, x_2, x_17, x_16);
+x_18 = l_Lean_FileMap_toPosition_loop(x_2, x_3, x_4, x_5, x_17, x_16);
 lean_dec(x_2);
 return x_18;
 }
@@ -636,18 +730,18 @@ l_Lean_Position_lt___closed__1 = _init_l_Lean_Position_lt___closed__1();
 lean_mark_persistent(l_Lean_Position_lt___closed__1);
 l_Lean_Position_lt___closed__2 = _init_l_Lean_Position_lt___closed__2();
 lean_mark_persistent(l_Lean_Position_lt___closed__2);
-l_Lean_Position_Lean_HasFormat___closed__1 = _init_l_Lean_Position_Lean_HasFormat___closed__1();
-lean_mark_persistent(l_Lean_Position_Lean_HasFormat___closed__1);
-l_Lean_Position_Lean_HasFormat___closed__2 = _init_l_Lean_Position_Lean_HasFormat___closed__2();
-lean_mark_persistent(l_Lean_Position_Lean_HasFormat___closed__2);
-l_Lean_Position_Inhabited___closed__1 = _init_l_Lean_Position_Inhabited___closed__1();
-lean_mark_persistent(l_Lean_Position_Inhabited___closed__1);
-l_Lean_Position_Inhabited = _init_l_Lean_Position_Inhabited();
-lean_mark_persistent(l_Lean_Position_Inhabited);
-l_Lean_FileMap_Inhabited___closed__1 = _init_l_Lean_FileMap_Inhabited___closed__1();
-lean_mark_persistent(l_Lean_FileMap_Inhabited___closed__1);
-l_Lean_FileMap_Inhabited = _init_l_Lean_FileMap_Inhabited();
-lean_mark_persistent(l_Lean_FileMap_Inhabited);
+l_Lean_Position_Lean_Data_Position___instance__2___closed__1 = _init_l_Lean_Position_Lean_Data_Position___instance__2___closed__1();
+lean_mark_persistent(l_Lean_Position_Lean_Data_Position___instance__2___closed__1);
+l_Lean_Position_Lean_Data_Position___instance__2___closed__2 = _init_l_Lean_Position_Lean_Data_Position___instance__2___closed__2();
+lean_mark_persistent(l_Lean_Position_Lean_Data_Position___instance__2___closed__2);
+l_Lean_Position_Lean_Data_Position___instance__4___closed__1 = _init_l_Lean_Position_Lean_Data_Position___instance__4___closed__1();
+lean_mark_persistent(l_Lean_Position_Lean_Data_Position___instance__4___closed__1);
+l_Lean_Position_Lean_Data_Position___instance__4 = _init_l_Lean_Position_Lean_Data_Position___instance__4();
+lean_mark_persistent(l_Lean_Position_Lean_Data_Position___instance__4);
+l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1 = _init_l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1();
+lean_mark_persistent(l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1);
+l_Lean_FileMap_Lean_Data_Position___instance__5 = _init_l_Lean_FileMap_Lean_Data_Position___instance__5();
+lean_mark_persistent(l_Lean_FileMap_Lean_Data_Position___instance__5);
 l_Lean_FileMap_ofString___closed__1 = _init_l_Lean_FileMap_ofString___closed__1();
 lean_mark_persistent(l_Lean_FileMap_ofString___closed__1);
 l_Lean_FileMap_ofString___closed__2 = _init_l_Lean_FileMap_ofString___closed__2();
diff --git a/stage0/stdlib/Lean/Data/SMap.c b/stage0/stdlib/Lean/Data/SMap.c
index 38b85f7806..860d769d35 100644
--- a/stage0/stdlib/Lean/Data/SMap.c
+++ b/stage0/stdlib/Lean/Data/SMap.c
@@ -17,15 +17,17 @@ lean_object* l_Lean_SMap_find_x21___rarg___closed__1;
 extern lean_object* l_Std_PersistentHashMap_empty___rarg___closed__2;
 lean_object* l_Lean_SMap_fold(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_foldStage2___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_find_x21___rarg___closed__3;
 extern lean_object* l_Std_HashMap_inhabited___closed__1;
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_SMap_foldStage2___spec__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Init_Util_1__mkPanicMessage(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_SMap_fold___spec__3___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_SMap_Inhabited___rarg(lean_object*, lean_object*);
-lean_object* l_Lean_SMap_Inhabited(lean_object*, lean_object*);
+uint8_t l_Lean_SMap_stage_u2081___default;
 lean_object* lean_array_get_size(lean_object*);
+lean_object* l_Lean_SMap_find_x3f_x27_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x3f_x27(lean_object*, lean_object*);
+lean_object* l_Lean_SMap_map_u2082___default(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__6___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_map_u2081___default___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_empty(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Std_AssocList_foldlM___at_Lean_SMap_fold___spec__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -35,11 +37,15 @@ lean_object* l_Lean_SMap_findD___rarg(lean_object*, lean_object*, lean_object*,
 lean_object* l_Std_HashMap_numBuckets___rarg(lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___main___at_Lean_SMap_foldStage2___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
+lean_object* l_Lean_SMap_find_x3f_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_Lean_Data_SMap___instance__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_SMap_foldStage2___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_numBuckets___rarg(lean_object*);
 lean_object* l_Std_PersistentHashMap_contains___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___main___at_Lean_SMap_foldStage2___spec__2___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_map_u2081___default(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_insert_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Std_PersistentHashMap_find_x21___rarg___closed__2;
 lean_object* l_Lean_SMap_findD(lean_object*, lean_object*);
 uint8_t l_Std_HashMapImp_contains___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -47,10 +53,13 @@ lean_object* l_Lean_SMap_insert___rarg(lean_object*, lean_object*, lean_object*,
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_foldStage2___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x21___rarg___closed__2;
 lean_object* l_Lean_SMap_switch(lean_object*, lean_object*);
+lean_object* l_Lean_SMap_Lean_Data_SMap___instance__1(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___main___at_Lean_SMap_fold___spec__4(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_SMap_fold___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_empty___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x3f_x27___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_find_x3f_x27_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_map_u2082___default___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_SMap_stageSizes___rarg(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_foldStage2___spec__4(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -70,7 +79,6 @@ lean_object* l_Lean_SMap_switch___rarg___boxed(lean_object*, lean_object*, lean_
 lean_object* l_Lean_SMap_stageSizes___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___main___at_Lean_SMap_fold___spec__4___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_foldStage2___spec__3(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_SMap_Inhabited___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_foldStage2___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__5___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_findD___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -81,28 +89,97 @@ lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_SMap_foldStage2___spec__1_
 lean_object* lean_panic_fn(lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_size___rarg___boxed(lean_object*);
+lean_object* l_Lean_SMap_find_x21_match__1(lean_object*, lean_object*);
+lean_object* l_Lean_SMap_contains_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_find_x3f_x27_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_contains_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_size___rarg(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlMAux___main___at_Lean_SMap_fold___spec__4___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_contains_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_switch___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__5(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_insert_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_contains___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_size(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x21___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_map_u2082___default___rarg(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_find_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_find_x3f_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_find_x21_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_numBuckets(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_stageSizes(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_SMap_fold___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_SMap_foldStage2___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_Lean_Data_SMap___instance__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_SMap_size___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SMap_insert_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SMap_find_x21(lean_object*, lean_object*);
 lean_object* l_Lean_SMap_fold___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Util_2__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_SMap_fold___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-lean_object* l_Lean_SMap_Inhabited___rarg(lean_object* x_1, lean_object* x_2) {
+static uint8_t _init_l_Lean_SMap_stage_u2081___default() {
+_start:
+{
+uint8_t x_1; 
+x_1 = 1;
+return x_1;
+}
+}
+lean_object* l_Lean_SMap_map_u2081___default(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_HashMap_inhabited___closed__1;
+return x_5;
+}
+}
+lean_object* l_Lean_SMap_map_u2081___default___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Lean_SMap_map_u2081___default(x_1, x_2, x_3, x_4);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
+lean_object* l_Lean_SMap_map_u2082___default___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = l_Std_PersistentHashMap_empty___rarg___closed__2;
+x_4 = lean_unsigned_to_nat(0u);
+x_5 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_5, 0, x_3);
+lean_ctor_set(x_5, 1, x_4);
+return x_5;
+}
+}
+lean_object* l_Lean_SMap_map_u2082___default(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_SMap_map_u2082___default___rarg___boxed), 2, 0);
+return x_3;
+}
+}
+lean_object* l_Lean_SMap_map_u2082___default___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = l_Lean_SMap_map_u2082___default___rarg(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+return x_3;
+}
+}
+lean_object* l_Lean_SMap_Lean_Data_SMap___instance__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; uint8_t x_6; lean_object* x_7; lean_object* x_8; 
@@ -120,19 +197,19 @@ lean_ctor_set_uint8(x_8, sizeof(void*)*2, x_6);
 return x_8;
 }
 }
-lean_object* l_Lean_SMap_Inhabited(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_SMap_Lean_Data_SMap___instance__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Lean_SMap_Inhabited___rarg___boxed), 2, 0);
+x_3 = lean_alloc_closure((void*)(l_Lean_SMap_Lean_Data_SMap___instance__1___rarg___boxed), 2, 0);
 return x_3;
 }
 }
-lean_object* l_Lean_SMap_Inhabited___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_SMap_Lean_Data_SMap___instance__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_SMap_Inhabited___rarg(x_1, x_2);
+x_3 = l_Lean_SMap_Lean_Data_SMap___instance__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -174,6 +251,55 @@ lean_dec(x_1);
 return x_3;
 }
 }
+lean_object* l_Lean_SMap_insert_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+uint8_t x_6; 
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*2);
+if (x_6 == 0)
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+lean_dec(x_1);
+x_9 = lean_apply_4(x_5, x_7, x_8, x_2, x_3);
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_5);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_1, 1);
+lean_inc(x_11);
+lean_dec(x_1);
+x_12 = lean_apply_4(x_4, x_10, x_11, x_2, x_3);
+return x_12;
+}
+}
+}
+lean_object* l_Lean_SMap_insert_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = lean_alloc_closure((void*)(l_Lean_SMap_insert_match__1___rarg), 5, 0);
+return x_6;
+}
+}
+lean_object* l_Lean_SMap_insert_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Lean_SMap_insert_match__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_6;
+}
+}
 lean_object* l_Lean_SMap_insert___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
@@ -185,54 +311,60 @@ uint8_t x_7;
 x_7 = !lean_is_exclusive(x_3);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; 
+lean_object* x_8; lean_object* x_9; uint8_t x_10; 
 x_8 = lean_ctor_get(x_3, 1);
 x_9 = l_Std_PersistentHashMap_insert___rarg(x_1, x_2, x_8, x_4, x_5);
+x_10 = 0;
 lean_ctor_set(x_3, 1, x_9);
+lean_ctor_set_uint8(x_3, sizeof(void*)*2, x_10);
 return x_3;
 }
 else
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
-x_10 = lean_ctor_get(x_3, 0);
-x_11 = lean_ctor_get(x_3, 1);
+lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; lean_object* x_15; 
+x_11 = lean_ctor_get(x_3, 0);
+x_12 = lean_ctor_get(x_3, 1);
+lean_inc(x_12);
 lean_inc(x_11);
-lean_inc(x_10);
 lean_dec(x_3);
-x_12 = l_Std_PersistentHashMap_insert___rarg(x_1, x_2, x_11, x_4, x_5);
-x_13 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_13, 0, x_10);
-lean_ctor_set(x_13, 1, x_12);
-lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_6);
-return x_13;
+x_13 = l_Std_PersistentHashMap_insert___rarg(x_1, x_2, x_12, x_4, x_5);
+x_14 = 0;
+x_15 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_15, 0, x_11);
+lean_ctor_set(x_15, 1, x_13);
+lean_ctor_set_uint8(x_15, sizeof(void*)*2, x_14);
+return x_15;
 }
 }
 else
 {
-uint8_t x_14; 
-x_14 = !lean_is_exclusive(x_3);
-if (x_14 == 0)
+uint8_t x_16; 
+x_16 = !lean_is_exclusive(x_3);
+if (x_16 == 0)
 {
-lean_object* x_15; lean_object* x_16; 
-x_15 = lean_ctor_get(x_3, 0);
-x_16 = l_Std_HashMapImp_insert___rarg(x_1, x_2, x_15, x_4, x_5);
-lean_ctor_set(x_3, 0, x_16);
+lean_object* x_17; lean_object* x_18; uint8_t x_19; 
+x_17 = lean_ctor_get(x_3, 0);
+x_18 = l_Std_HashMapImp_insert___rarg(x_1, x_2, x_17, x_4, x_5);
+x_19 = 1;
+lean_ctor_set(x_3, 0, x_18);
+lean_ctor_set_uint8(x_3, sizeof(void*)*2, x_19);
 return x_3;
 }
 else
 {
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
-x_17 = lean_ctor_get(x_3, 0);
-x_18 = lean_ctor_get(x_3, 1);
-lean_inc(x_18);
-lean_inc(x_17);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; 
+x_20 = lean_ctor_get(x_3, 0);
+x_21 = lean_ctor_get(x_3, 1);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_3);
-x_19 = l_Std_HashMapImp_insert___rarg(x_1, x_2, x_17, x_4, x_5);
-x_20 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_20, 0, x_19);
-lean_ctor_set(x_20, 1, x_18);
-lean_ctor_set_uint8(x_20, sizeof(void*)*2, x_6);
-return x_20;
+x_22 = l_Std_HashMapImp_insert___rarg(x_1, x_2, x_20, x_4, x_5);
+x_23 = 1;
+x_24 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_24, 0, x_22);
+lean_ctor_set(x_24, 1, x_21);
+lean_ctor_set_uint8(x_24, sizeof(void*)*2, x_23);
+return x_24;
 }
 }
 }
@@ -245,6 +377,55 @@ x_3 = lean_alloc_closure((void*)(l_Lean_SMap_insert___rarg), 5, 0);
 return x_3;
 }
 }
+lean_object* l_Lean_SMap_find_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*2);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_3(x_4, x_6, x_7, x_2);
+return x_8;
+}
+else
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_apply_3(x_3, x_9, x_10, x_2);
+return x_11;
+}
+}
+}
+lean_object* l_Lean_SMap_find_x3f_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = lean_alloc_closure((void*)(l_Lean_SMap_find_x3f_match__1___rarg), 4, 0);
+return x_6;
+}
+}
+lean_object* l_Lean_SMap_find_x3f_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Lean_SMap_find_x3f_match__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_6;
+}
+}
 lean_object* l_Lean_SMap_find_x3f___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -335,6 +516,37 @@ lean_dec(x_5);
 return x_6;
 }
 }
+lean_object* l_Lean_SMap_find_x21_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_SMap_find_x21_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_SMap_find_x21_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 static lean_object* _init_l_Lean_SMap_find_x21___rarg___closed__1() {
 _start:
 {
@@ -346,13 +558,22 @@ return x_1;
 static lean_object* _init_l_Lean_SMap_find_x21___rarg___closed__2() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; 
+x_1 = lean_mk_string("Lean.SMap.find!");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_SMap_find_x21___rarg___closed__3() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_SMap_find_x21___rarg___closed__1;
-x_2 = lean_unsigned_to_nat(55u);
-x_3 = lean_unsigned_to_nat(12u);
-x_4 = l_Std_PersistentHashMap_find_x21___rarg___closed__2;
-x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
-return x_5;
+x_2 = l_Lean_SMap_find_x21___rarg___closed__2;
+x_3 = lean_unsigned_to_nat(56u);
+x_4 = lean_unsigned_to_nat(12u);
+x_5 = l_Std_PersistentHashMap_find_x21___rarg___closed__2;
+x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
+return x_6;
 }
 }
 lean_object* l_Lean_SMap_find_x21___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
@@ -363,7 +584,7 @@ x_6 = l_Lean_SMap_find_x3f___rarg(x_1, x_2, x_4, x_5);
 if (lean_obj_tag(x_6) == 0)
 {
 lean_object* x_7; lean_object* x_8; 
-x_7 = l_Lean_SMap_find_x21___rarg___closed__2;
+x_7 = l_Lean_SMap_find_x21___rarg___closed__3;
 x_8 = lean_panic_fn(x_3, x_7);
 return x_8;
 }
@@ -386,6 +607,55 @@ x_3 = lean_alloc_closure((void*)(l_Lean_SMap_find_x21___rarg), 5, 0);
 return x_3;
 }
 }
+lean_object* l_Lean_SMap_contains_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*2);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_3(x_4, x_6, x_7, x_2);
+return x_8;
+}
+else
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_apply_3(x_3, x_9, x_10, x_2);
+return x_11;
+}
+}
+}
+lean_object* l_Lean_SMap_contains_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = lean_alloc_closure((void*)(l_Lean_SMap_contains_match__1___rarg), 4, 0);
+return x_6;
+}
+}
+lean_object* l_Lean_SMap_contains_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Lean_SMap_contains_match__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_6;
+}
+}
 lean_object* l_Lean_SMap_contains___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -443,6 +713,55 @@ x_3 = lean_alloc_closure((void*)(l_Lean_SMap_contains___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Lean_SMap_find_x3f_x27_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*2);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_3(x_4, x_6, x_7, x_2);
+return x_8;
+}
+else
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_apply_3(x_3, x_9, x_10, x_2);
+return x_11;
+}
+}
+}
+lean_object* l_Lean_SMap_find_x3f_x27_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = lean_alloc_closure((void*)(l_Lean_SMap_find_x3f_x27_match__1___rarg), 4, 0);
+return x_6;
+}
+}
+lean_object* l_Lean_SMap_find_x3f_x27_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Lean_SMap_find_x3f_x27_match__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+return x_6;
+}
+}
 lean_object* l_Lean_SMap_find_x3f_x27___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -1224,10 +1543,13 @@ lean_dec_ref(res);
 res = initialize_Std_Data_PersistentHashMap(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
+l_Lean_SMap_stage_u2081___default = _init_l_Lean_SMap_stage_u2081___default();
 l_Lean_SMap_find_x21___rarg___closed__1 = _init_l_Lean_SMap_find_x21___rarg___closed__1();
 lean_mark_persistent(l_Lean_SMap_find_x21___rarg___closed__1);
 l_Lean_SMap_find_x21___rarg___closed__2 = _init_l_Lean_SMap_find_x21___rarg___closed__2();
 lean_mark_persistent(l_Lean_SMap_find_x21___rarg___closed__2);
+l_Lean_SMap_find_x21___rarg___closed__3 = _init_l_Lean_SMap_find_x21___rarg___closed__3();
+lean_mark_persistent(l_Lean_SMap_find_x21___rarg___closed__3);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Data/Trie.c b/stage0/stdlib/Lean/Data/Trie.c
index cdcb359d61..fc251f4d97 100644
--- a/stage0/stdlib/Lean/Data/Trie.c
+++ b/stage0/stdlib/Lean/Data/Trie.c
@@ -13,96 +13,111 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l___private_Lean_Data_Trie_4__updtAcc(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop(lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop_match__2(lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty(lean_object*);
 lean_object* l_Lean_Parser_Trie_find_x3f(lean_object*);
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2(lean_object*);
-lean_object* l___private_Lean_Data_Trie_6__toStringAux___main___rarg(lean_object*);
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main(lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg(lean_object*, uint32_t, lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__2___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__2(lean_object*);
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_singleton___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Format_pretty(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Trie_HasEmptyc(lean_object*);
-lean_object* l_Lean_Parser_Trie_HasToString___rarg(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1___rarg(lean_object*, uint32_t);
 lean_object* l_Lean_Parser_Trie_matchPrefix___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(lean_object*, uint32_t, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop_match__1(lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux_match__1___rarg(lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc(lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__3___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Trie_empty(lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1___rarg(lean_object*, uint32_t);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_6__toStringAux___rarg(lean_object*);
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___main(lean_object*);
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6(lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__1(lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux(lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7(lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Trie_matchPrefix___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_utf8_next(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg(lean_object*, uint32_t);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(lean_object*, uint32_t, lean_object*);
-lean_object* l_Lean_Parser_Trie_HasEmptyc___closed__1;
-lean_object* l___private_Lean_Data_Trie_4__updtAcc___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__2___rarg(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
-lean_object* l___private_Lean_Data_Trie_2__insertAux___main(lean_object*);
-lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(lean_object*, uint32_t, lean_object*);
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__3(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__2(lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux_match__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(lean_object*, uint32_t, lean_object*);
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1;
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg(lean_object*, uint32_t);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg___closed__1;
 uint8_t l_UInt32_decLt(uint32_t, uint32_t);
-extern lean_object* l_stdNext___closed__1;
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__3___rarg(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(lean_object*, uint32_t, lean_object*);
 extern lean_object* l_Char_HasRepr___closed__1;
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Trie_find_x3f___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1___rarg(lean_object*, uint32_t);
+lean_object* l_Lean_Parser_Trie_insert_loop_match__2___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc_match__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1___rarg(lean_object*, uint32_t);
 lean_object* l_Lean_Parser_Trie_insert___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___main(lean_object*);
 lean_object* l_Lean_Parser_Trie_matchPrefix(lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__1(lean_object*, lean_object*);
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_2__insertAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Trie_HasToString(lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1___rarg___boxed(lean_object*, lean_object*);
-lean_object* l_Lean_Parser_Trie_Inhabited(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_2__insertAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3(lean_object*);
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__3(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop_match__3(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty_match__1___rarg(uint8_t, lean_object*, lean_object*);
+lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty_match__1(lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__1(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop_match__2___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Trie_insert___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1___rarg___boxed(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_2__insertAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg(lean_object*, uint32_t, lean_object*);
 uint8_t l_Std_RBNode_isRed___rarg(lean_object*);
-lean_object* l___private_Lean_Data_Trie_4__updtAcc___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(lean_object*, uint32_t, lean_object*);
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4(lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1(lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__2___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(lean_object*, uint32_t, lean_object*);
 lean_object* l_Lean_Parser_Trie_empty___closed__1;
-lean_object* l___private_Lean_Data_Trie_2__insertAux(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3(lean_object*);
 lean_object* l_Lean_Parser_Trie_find_x3f___rarg___boxed(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_2__insertAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux(lean_object*);
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg(lean_object*, uint32_t, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__2(lean_object*);
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1___boxed(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_6__toStringAux(lean_object*);
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg(lean_object*, uint32_t, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__3(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(lean_object*, uint32_t, lean_object*);
+lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___rarg(lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__2___rarg(uint8_t, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4(lean_object*);
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5(lean_object*);
 lean_object* l_Char_quoteCore(uint32_t);
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2(lean_object*);
 uint8_t lean_string_utf8_at_end(lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux(lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1(lean_object*);
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1(lean_object*);
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_6__toStringAux___main(lean_object*);
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7(lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__2___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__2(lean_object*);
+lean_object* lean_nat_to_int(lean_object*);
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Trie_insert(lean_object*);
+lean_object* l_Lean_Parser_Trie_find_x3f_loop___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1(lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2(lean_object*);
 static lean_object* _init_l_Lean_Parser_Trie_empty___closed__1() {
 _start:
 {
@@ -123,7 +138,7 @@ x_2 = l_Lean_Parser_Trie_empty___closed__1;
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Parser_Trie_HasEmptyc___closed__1() {
+static lean_object* _init_l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -131,15 +146,15 @@ x_1 = l_Lean_Parser_Trie_empty(lean_box(0));
 return x_1;
 }
 }
-lean_object* l_Lean_Parser_Trie_HasEmptyc(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Lean_Parser_Trie_HasEmptyc___closed__1;
+x_2 = l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1;
 return x_2;
 }
 }
-lean_object* l_Lean_Parser_Trie_Inhabited(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -147,7 +162,137 @@ x_2 = l_Lean_Parser_Trie_empty___closed__1;
 return x_2;
 }
 }
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty_match__1___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (x_1 == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_insert_insertEmpty_match__1___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty_match__1___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 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_Lean_Parser_Trie_insert_insertEmpty_match__1___rarg(x_4, x_2, x_3);
+return x_5;
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_loop_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_loop_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_insert_loop_match__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_loop_match__2___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (x_1 == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_loop_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_insert_loop_match__2___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_loop_match__2___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 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_Lean_Parser_Trie_insert_loop_match__2___rarg(x_4, x_2, x_3);
+return x_5;
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_loop_match__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_3(x_3, x_4, x_5, x_2);
+return x_6;
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_loop_match__3(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_insert_loop_match__3___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint8_t x_4; 
@@ -157,7 +302,7 @@ if (x_4 == 0)
 uint32_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_5 = lean_string_utf8_get(x_1, x_3);
 x_6 = lean_string_utf8_next(x_1, x_3);
-x_7 = l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg(x_1, x_2, x_6);
+x_7 = l_Lean_Parser_Trie_insert_insertEmpty___rarg(x_1, x_2, x_6);
 lean_dec(x_6);
 x_8 = lean_box(0);
 x_9 = lean_box_uint32(x_5);
@@ -180,51 +325,25 @@ return x_14;
 }
 }
 }
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___main(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_insert_insertEmpty___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Trie_insert_insertEmpty___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg(x_1, x_2, x_3);
+x_4 = l_Lean_Parser_Trie_insert_insertEmpty___rarg(x_1, x_2, x_3);
 lean_dec(x_3);
 lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg(x_1, x_2, x_3);
-return x_4;
-}
-}
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_1__insertEmptyAux___rarg___boxed), 3, 0);
-return x_2;
-}
-}
-lean_object* l___private_Lean_Data_Trie_1__insertEmptyAux___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l___private_Lean_Data_Trie_1__insertEmptyAux___rarg(x_1, x_2, x_3);
-lean_dec(x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg(lean_object* x_1, uint32_t x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg(lean_object* x_1, uint32_t x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -280,2403 +399,2478 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; lean_object* x_6; 
-x_4 = 0;
-x_5 = lean_box_uint32(x_2);
-x_6 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_6, 0, x_1);
-lean_ctor_set(x_6, 1, x_5);
-lean_ctor_set(x_6, 2, x_3);
-lean_ctor_set(x_6, 3, x_1);
-lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_4);
-return x_6;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_box_uint32(x_2);
+x_7 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 2, x_3);
+lean_ctor_set(x_7, 3, x_4);
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_5);
+return x_7;
 }
 else
 {
-uint8_t x_7; 
-x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_7 == 0)
-{
 uint8_t x_8; 
-x_8 = !lean_is_exclusive(x_1);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_8 == 0)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint32_t x_13; uint8_t x_14; 
-x_9 = lean_ctor_get(x_1, 0);
-x_10 = lean_ctor_get(x_1, 1);
-x_11 = lean_ctor_get(x_1, 2);
-x_12 = lean_ctor_get(x_1, 3);
-x_13 = lean_unbox_uint32(x_10);
-x_14 = x_2 < x_13;
-if (x_14 == 0)
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_1);
+if (x_9 == 0)
 {
-uint32_t x_15; uint8_t x_16; 
-x_15 = lean_unbox_uint32(x_10);
-x_16 = x_15 < x_2;
-if (x_16 == 0)
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint32_t x_14; uint8_t x_15; 
+x_10 = lean_ctor_get(x_1, 0);
+x_11 = lean_ctor_get(x_1, 1);
+x_12 = lean_ctor_get(x_1, 2);
+x_13 = lean_ctor_get(x_1, 3);
+x_14 = lean_unbox_uint32(x_11);
+x_15 = x_2 < x_14;
+if (x_15 == 0)
 {
-lean_object* x_17; 
+uint32_t x_16; uint8_t x_17; 
+x_16 = lean_unbox_uint32(x_11);
+x_17 = x_16 < x_2;
+if (x_17 == 0)
+{
+uint8_t x_18; lean_object* x_19; 
+lean_dec(x_12);
 lean_dec(x_11);
-lean_dec(x_10);
-x_17 = lean_box_uint32(x_2);
+x_18 = 0;
+x_19 = lean_box_uint32(x_2);
 lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_17);
+lean_ctor_set(x_1, 1, x_19);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_18);
 return x_1;
 }
 else
 {
-lean_object* x_18; 
-x_18 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_12, x_2, x_3);
-lean_ctor_set(x_1, 3, x_18);
+lean_object* x_20; uint8_t x_21; 
+x_20 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_13, x_2, x_3);
+x_21 = 0;
+lean_ctor_set(x_1, 3, x_20);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_21);
 return x_1;
 }
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_9, x_2, x_3);
-lean_ctor_set(x_1, 0, x_19);
+lean_object* x_22; uint8_t x_23; 
+x_22 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_10, x_2, x_3);
+x_23 = 0;
+lean_ctor_set(x_1, 0, x_22);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_23);
 return x_1;
 }
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint32_t x_24; uint8_t x_25; 
-x_20 = lean_ctor_get(x_1, 0);
-x_21 = lean_ctor_get(x_1, 1);
-x_22 = lean_ctor_get(x_1, 2);
-x_23 = lean_ctor_get(x_1, 3);
-lean_inc(x_23);
-lean_inc(x_22);
-lean_inc(x_21);
-lean_inc(x_20);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint32_t x_28; uint8_t x_29; 
+x_24 = lean_ctor_get(x_1, 0);
+x_25 = lean_ctor_get(x_1, 1);
+x_26 = lean_ctor_get(x_1, 2);
+x_27 = lean_ctor_get(x_1, 3);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_inc(x_24);
 lean_dec(x_1);
-x_24 = lean_unbox_uint32(x_21);
-x_25 = x_2 < x_24;
-if (x_25 == 0)
+x_28 = lean_unbox_uint32(x_25);
+x_29 = x_2 < x_28;
+if (x_29 == 0)
 {
-uint32_t x_26; uint8_t x_27; 
-x_26 = lean_unbox_uint32(x_21);
-x_27 = x_26 < x_2;
-if (x_27 == 0)
+uint32_t x_30; uint8_t x_31; 
+x_30 = lean_unbox_uint32(x_25);
+x_31 = x_30 < x_2;
+if (x_31 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_21);
-x_28 = lean_box_uint32(x_2);
-x_29 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_29, 0, x_20);
-lean_ctor_set(x_29, 1, x_28);
-lean_ctor_set(x_29, 2, x_3);
-lean_ctor_set(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, sizeof(void*)*4, x_7);
-return x_29;
+uint8_t x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_26);
+lean_dec(x_25);
+x_32 = 0;
+x_33 = lean_box_uint32(x_2);
+x_34 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_34, 0, x_24);
+lean_ctor_set(x_34, 1, x_33);
+lean_ctor_set(x_34, 2, x_3);
+lean_ctor_set(x_34, 3, x_27);
+lean_ctor_set_uint8(x_34, sizeof(void*)*4, x_32);
+return x_34;
 }
 else
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_23, x_2, x_3);
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_20);
-lean_ctor_set(x_31, 1, x_21);
-lean_ctor_set(x_31, 2, x_22);
-lean_ctor_set(x_31, 3, x_30);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_7);
-return x_31;
+lean_object* x_35; uint8_t x_36; lean_object* x_37; 
+x_35 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_27, x_2, x_3);
+x_36 = 0;
+x_37 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_37, 0, x_24);
+lean_ctor_set(x_37, 1, x_25);
+lean_ctor_set(x_37, 2, x_26);
+lean_ctor_set(x_37, 3, x_35);
+lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
+return x_37;
 }
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_20, x_2, x_3);
-x_33 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_21);
-lean_ctor_set(x_33, 2, x_22);
-lean_ctor_set(x_33, 3, x_23);
-lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_7);
-return x_33;
+lean_object* x_38; uint8_t x_39; lean_object* x_40; 
+x_38 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_24, x_2, x_3);
+x_39 = 0;
+x_40 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_25);
+lean_ctor_set(x_40, 2, x_26);
+lean_ctor_set(x_40, 3, x_27);
+lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = !lean_is_exclusive(x_1);
-if (x_34 == 0)
+uint8_t x_41; 
+x_41 = !lean_is_exclusive(x_1);
+if (x_41 == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint32_t x_39; uint8_t x_40; 
-x_35 = lean_ctor_get(x_1, 0);
-x_36 = lean_ctor_get(x_1, 1);
-x_37 = lean_ctor_get(x_1, 2);
-x_38 = lean_ctor_get(x_1, 3);
-x_39 = lean_unbox_uint32(x_36);
-x_40 = x_2 < x_39;
-if (x_40 == 0)
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint32_t x_46; uint8_t x_47; 
+x_42 = lean_ctor_get(x_1, 0);
+x_43 = lean_ctor_get(x_1, 1);
+x_44 = lean_ctor_get(x_1, 2);
+x_45 = lean_ctor_get(x_1, 3);
+x_46 = lean_unbox_uint32(x_43);
+x_47 = x_2 < x_46;
+if (x_47 == 0)
 {
-uint32_t x_41; uint8_t x_42; 
-x_41 = lean_unbox_uint32(x_36);
-x_42 = x_41 < x_2;
-if (x_42 == 0)
-{
-lean_object* x_43; 
-lean_dec(x_37);
-lean_dec(x_36);
-x_43 = lean_box_uint32(x_2);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_43);
-return x_1;
-}
-else
-{
-uint8_t x_44; 
-x_44 = l_Std_RBNode_isRed___rarg(x_38);
-if (x_44 == 0)
-{
-lean_object* x_45; 
-x_45 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_38, x_2, x_3);
-lean_ctor_set(x_1, 3, x_45);
-return x_1;
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-x_46 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_38, x_2, x_3);
-x_47 = lean_ctor_get(x_46, 0);
-lean_inc(x_47);
-if (lean_obj_tag(x_47) == 0)
-{
-lean_object* x_48; 
-x_48 = lean_ctor_get(x_46, 3);
-lean_inc(x_48);
-if (lean_obj_tag(x_48) == 0)
-{
-uint8_t x_49; 
-x_49 = !lean_is_exclusive(x_46);
+uint32_t x_48; uint8_t x_49; 
+x_48 = lean_unbox_uint32(x_43);
+x_49 = x_48 < x_2;
 if (x_49 == 0)
 {
-lean_object* x_50; lean_object* x_51; uint8_t x_52; uint8_t x_53; 
-x_50 = lean_ctor_get(x_46, 3);
-lean_dec(x_50);
-x_51 = lean_ctor_get(x_46, 0);
-lean_dec(x_51);
-x_52 = 0;
-lean_ctor_set(x_46, 0, x_48);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_52);
-x_53 = 1;
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_53);
+uint8_t x_50; lean_object* x_51; 
+lean_dec(x_44);
+lean_dec(x_43);
+x_50 = 1;
+x_51 = lean_box_uint32(x_2);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_51);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_50);
 return x_1;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; 
-x_54 = lean_ctor_get(x_46, 1);
-x_55 = lean_ctor_get(x_46, 2);
-lean_inc(x_55);
-lean_inc(x_54);
-lean_dec(x_46);
-x_56 = 0;
-x_57 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_57, 0, x_48);
-lean_ctor_set(x_57, 1, x_54);
-lean_ctor_set(x_57, 2, x_55);
-lean_ctor_set(x_57, 3, x_48);
-lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_56);
-x_58 = 1;
-lean_ctor_set(x_1, 3, x_57);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_58);
+uint8_t x_52; 
+x_52 = l_Std_RBNode_isRed___rarg(x_45);
+if (x_52 == 0)
+{
+lean_object* x_53; uint8_t x_54; 
+x_53 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_45, x_2, x_3);
+x_54 = 1;
+lean_ctor_set(x_1, 3, x_53);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_54);
+return x_1;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_45, x_2, x_3);
+x_56 = lean_ctor_get(x_55, 0);
+lean_inc(x_56);
+if (lean_obj_tag(x_56) == 0)
+{
+lean_object* x_57; 
+x_57 = lean_ctor_get(x_55, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
+{
+uint8_t x_58; 
+x_58 = !lean_is_exclusive(x_55);
+if (x_58 == 0)
+{
+lean_object* x_59; lean_object* x_60; uint8_t x_61; uint8_t x_62; 
+x_59 = lean_ctor_get(x_55, 3);
+lean_dec(x_59);
+x_60 = lean_ctor_get(x_55, 0);
+lean_dec(x_60);
+x_61 = 0;
+lean_ctor_set(x_55, 0, x_57);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_61);
+x_62 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_62);
+return x_1;
+}
+else
+{
+lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; uint8_t x_67; 
+x_63 = lean_ctor_get(x_55, 1);
+x_64 = lean_ctor_get(x_55, 2);
+lean_inc(x_64);
+lean_inc(x_63);
+lean_dec(x_55);
+x_65 = 0;
+x_66 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_66, 0, x_57);
+lean_ctor_set(x_66, 1, x_63);
+lean_ctor_set(x_66, 2, x_64);
+lean_ctor_set(x_66, 3, x_57);
+lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
+x_67 = 1;
+lean_ctor_set(x_1, 3, x_66);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_67);
 return x_1;
 }
 }
 else
 {
-uint8_t x_59; 
-x_59 = lean_ctor_get_uint8(x_48, sizeof(void*)*4);
-if (x_59 == 0)
+uint8_t x_68; 
+x_68 = lean_ctor_get_uint8(x_57, sizeof(void*)*4);
+if (x_68 == 0)
 {
-uint8_t x_60; 
-x_60 = !lean_is_exclusive(x_46);
-if (x_60 == 0)
+uint8_t x_69; 
+x_69 = !lean_is_exclusive(x_55);
+if (x_69 == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; 
-x_61 = lean_ctor_get(x_46, 1);
-x_62 = lean_ctor_get(x_46, 2);
-x_63 = lean_ctor_get(x_46, 3);
-lean_dec(x_63);
-x_64 = lean_ctor_get(x_46, 0);
-lean_dec(x_64);
-x_65 = !lean_is_exclusive(x_48);
-if (x_65 == 0)
+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_55, 1);
+x_71 = lean_ctor_get(x_55, 2);
+x_72 = lean_ctor_get(x_55, 3);
+lean_dec(x_72);
+x_73 = lean_ctor_get(x_55, 0);
+lean_dec(x_73);
+x_74 = !lean_is_exclusive(x_57);
+if (x_74 == 0)
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; 
-x_66 = lean_ctor_get(x_48, 0);
-x_67 = lean_ctor_get(x_48, 1);
-x_68 = lean_ctor_get(x_48, 2);
-x_69 = lean_ctor_get(x_48, 3);
-x_70 = 1;
-lean_ctor_set(x_48, 3, x_47);
-lean_ctor_set(x_48, 2, x_37);
-lean_ctor_set(x_48, 1, x_36);
-lean_ctor_set(x_48, 0, x_35);
-lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_70);
-lean_ctor_set(x_46, 3, x_69);
-lean_ctor_set(x_46, 2, x_68);
-lean_ctor_set(x_46, 1, x_67);
-lean_ctor_set(x_46, 0, x_66);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_70);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_48);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; uint8_t x_80; 
+x_75 = lean_ctor_get(x_57, 0);
+x_76 = lean_ctor_get(x_57, 1);
+x_77 = lean_ctor_get(x_57, 2);
+x_78 = lean_ctor_get(x_57, 3);
+x_79 = 1;
+lean_ctor_set(x_57, 3, x_56);
+lean_ctor_set(x_57, 2, x_44);
+lean_ctor_set(x_57, 1, x_43);
+lean_ctor_set(x_57, 0, x_42);
+lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_79);
+lean_ctor_set(x_55, 3, x_78);
+lean_ctor_set(x_55, 2, x_77);
+lean_ctor_set(x_55, 1, x_76);
+lean_ctor_set(x_55, 0, x_75);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_79);
+x_80 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_57);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_80);
 return x_1;
 }
 else
 {
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; 
-x_71 = lean_ctor_get(x_48, 0);
-x_72 = lean_ctor_get(x_48, 1);
-x_73 = lean_ctor_get(x_48, 2);
-x_74 = lean_ctor_get(x_48, 3);
-lean_inc(x_74);
-lean_inc(x_73);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_dec(x_48);
-x_75 = 1;
-x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_35);
-lean_ctor_set(x_76, 1, x_36);
-lean_ctor_set(x_76, 2, x_37);
-lean_ctor_set(x_76, 3, x_47);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
-lean_ctor_set(x_46, 3, x_74);
-lean_ctor_set(x_46, 2, x_73);
-lean_ctor_set(x_46, 1, x_72);
-lean_ctor_set(x_46, 0, x_71);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_75);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_76);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-}
-else
-{
-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; uint8_t x_84; lean_object* x_85; lean_object* x_86; 
-x_77 = lean_ctor_get(x_46, 1);
-x_78 = lean_ctor_get(x_46, 2);
-lean_inc(x_78);
-lean_inc(x_77);
-lean_dec(x_46);
-x_79 = lean_ctor_get(x_48, 0);
-lean_inc(x_79);
-x_80 = lean_ctor_get(x_48, 1);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_48, 2);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_48, 3);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; lean_object* x_86; uint8_t x_87; 
+x_81 = lean_ctor_get(x_57, 0);
+x_82 = lean_ctor_get(x_57, 1);
+x_83 = lean_ctor_get(x_57, 2);
+x_84 = lean_ctor_get(x_57, 3);
+lean_inc(x_84);
+lean_inc(x_83);
 lean_inc(x_82);
-if (lean_is_exclusive(x_48)) {
- lean_ctor_release(x_48, 0);
- lean_ctor_release(x_48, 1);
- lean_ctor_release(x_48, 2);
- lean_ctor_release(x_48, 3);
- x_83 = x_48;
-} else {
- lean_dec_ref(x_48);
- x_83 = lean_box(0);
-}
-x_84 = 1;
-if (lean_is_scalar(x_83)) {
- x_85 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_85 = x_83;
-}
-lean_ctor_set(x_85, 0, x_35);
-lean_ctor_set(x_85, 1, x_36);
-lean_ctor_set(x_85, 2, x_37);
-lean_ctor_set(x_85, 3, x_47);
-lean_ctor_set_uint8(x_85, sizeof(void*)*4, x_84);
+lean_inc(x_81);
+lean_dec(x_57);
+x_85 = 1;
 x_86 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_86, 0, x_79);
-lean_ctor_set(x_86, 1, x_80);
-lean_ctor_set(x_86, 2, x_81);
-lean_ctor_set(x_86, 3, x_82);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_84);
-lean_ctor_set(x_1, 3, x_86);
-lean_ctor_set(x_1, 2, x_78);
-lean_ctor_set(x_1, 1, x_77);
-lean_ctor_set(x_1, 0, x_85);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_ctor_set(x_86, 0, x_42);
+lean_ctor_set(x_86, 1, x_43);
+lean_ctor_set(x_86, 2, x_44);
+lean_ctor_set(x_86, 3, x_56);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+lean_ctor_set(x_55, 3, x_84);
+lean_ctor_set(x_55, 2, x_83);
+lean_ctor_set(x_55, 1, x_82);
+lean_ctor_set(x_55, 0, x_81);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_85);
+x_87 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_87);
 return x_1;
 }
 }
 else
 {
-uint8_t x_87; 
-x_87 = !lean_is_exclusive(x_46);
-if (x_87 == 0)
-{
-lean_object* x_88; lean_object* x_89; uint8_t x_90; 
-x_88 = lean_ctor_get(x_46, 3);
-lean_dec(x_88);
-x_89 = lean_ctor_get(x_46, 0);
-lean_dec(x_89);
-x_90 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_90);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-else
-{
-lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; 
-x_91 = lean_ctor_get(x_46, 1);
-x_92 = lean_ctor_get(x_46, 2);
-lean_inc(x_92);
+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; uint8_t x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; 
+x_88 = lean_ctor_get(x_55, 1);
+x_89 = lean_ctor_get(x_55, 2);
+lean_inc(x_89);
+lean_inc(x_88);
+lean_dec(x_55);
+x_90 = lean_ctor_get(x_57, 0);
+lean_inc(x_90);
+x_91 = lean_ctor_get(x_57, 1);
 lean_inc(x_91);
-lean_dec(x_46);
-x_93 = 0;
-x_94 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_94, 0, x_47);
-lean_ctor_set(x_94, 1, x_91);
-lean_ctor_set(x_94, 2, x_92);
-lean_ctor_set(x_94, 3, x_48);
-lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_94);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+x_92 = lean_ctor_get(x_57, 2);
+lean_inc(x_92);
+x_93 = lean_ctor_get(x_57, 3);
+lean_inc(x_93);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ lean_ctor_release(x_57, 2);
+ lean_ctor_release(x_57, 3);
+ x_94 = x_57;
+} else {
+ lean_dec_ref(x_57);
+ x_94 = lean_box(0);
+}
+x_95 = 1;
+if (lean_is_scalar(x_94)) {
+ x_96 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_96 = x_94;
+}
+lean_ctor_set(x_96, 0, x_42);
+lean_ctor_set(x_96, 1, x_43);
+lean_ctor_set(x_96, 2, x_44);
+lean_ctor_set(x_96, 3, x_56);
+lean_ctor_set_uint8(x_96, sizeof(void*)*4, x_95);
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_90);
+lean_ctor_set(x_97, 1, x_91);
+lean_ctor_set(x_97, 2, x_92);
+lean_ctor_set(x_97, 3, x_93);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_95);
+x_98 = 0;
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set(x_1, 2, x_89);
+lean_ctor_set(x_1, 1, x_88);
+lean_ctor_set(x_1, 0, x_96);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_95; 
-x_95 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
-if (x_95 == 0)
+uint8_t x_99; 
+x_99 = !lean_is_exclusive(x_55);
+if (x_99 == 0)
 {
-uint8_t x_96; 
-x_96 = !lean_is_exclusive(x_46);
-if (x_96 == 0)
-{
-lean_object* x_97; uint8_t x_98; 
-x_97 = lean_ctor_get(x_46, 0);
-lean_dec(x_97);
-x_98 = !lean_is_exclusive(x_47);
-if (x_98 == 0)
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; uint8_t x_103; 
-x_99 = lean_ctor_get(x_47, 0);
-x_100 = lean_ctor_get(x_47, 1);
-x_101 = lean_ctor_get(x_47, 2);
-x_102 = lean_ctor_get(x_47, 3);
+lean_object* x_100; lean_object* x_101; uint8_t x_102; uint8_t x_103; 
+x_100 = lean_ctor_get(x_55, 3);
+lean_dec(x_100);
+x_101 = lean_ctor_get(x_55, 0);
+lean_dec(x_101);
+x_102 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_102);
 x_103 = 1;
-lean_ctor_set(x_47, 3, x_99);
-lean_ctor_set(x_47, 2, x_37);
-lean_ctor_set(x_47, 1, x_36);
-lean_ctor_set(x_47, 0, x_35);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_103);
-lean_ctor_set(x_46, 0, x_102);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_103);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_101);
-lean_ctor_set(x_1, 1, x_100);
-lean_ctor_set(x_1, 0, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_103);
 return x_1;
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; 
-x_104 = lean_ctor_get(x_47, 0);
-x_105 = lean_ctor_get(x_47, 1);
-x_106 = lean_ctor_get(x_47, 2);
-x_107 = lean_ctor_get(x_47, 3);
-lean_inc(x_107);
-lean_inc(x_106);
+lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; uint8_t x_108; 
+x_104 = lean_ctor_get(x_55, 1);
+x_105 = lean_ctor_get(x_55, 2);
 lean_inc(x_105);
 lean_inc(x_104);
-lean_dec(x_47);
+lean_dec(x_55);
+x_106 = 0;
+x_107 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_107, 0, x_56);
+lean_ctor_set(x_107, 1, x_104);
+lean_ctor_set(x_107, 2, x_105);
+lean_ctor_set(x_107, 3, x_57);
+lean_ctor_set_uint8(x_107, sizeof(void*)*4, x_106);
 x_108 = 1;
-x_109 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_109, 0, x_35);
-lean_ctor_set(x_109, 1, x_36);
-lean_ctor_set(x_109, 2, x_37);
-lean_ctor_set(x_109, 3, x_104);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-lean_ctor_set(x_46, 0, x_107);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_106);
-lean_ctor_set(x_1, 1, x_105);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_107);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; lean_object* x_120; 
-x_110 = lean_ctor_get(x_46, 1);
-x_111 = lean_ctor_get(x_46, 2);
-x_112 = lean_ctor_get(x_46, 3);
-lean_inc(x_112);
-lean_inc(x_111);
-lean_inc(x_110);
-lean_dec(x_46);
-x_113 = lean_ctor_get(x_47, 0);
-lean_inc(x_113);
-x_114 = lean_ctor_get(x_47, 1);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_47, 2);
-lean_inc(x_115);
-x_116 = lean_ctor_get(x_47, 3);
-lean_inc(x_116);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_117 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_117 = lean_box(0);
-}
-x_118 = 1;
-if (lean_is_scalar(x_117)) {
- x_119 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_119 = x_117;
-}
-lean_ctor_set(x_119, 0, x_35);
-lean_ctor_set(x_119, 1, x_36);
-lean_ctor_set(x_119, 2, x_37);
-lean_ctor_set(x_119, 3, x_113);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-x_120 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_120, 0, x_116);
-lean_ctor_set(x_120, 1, x_110);
-lean_ctor_set(x_120, 2, x_111);
-lean_ctor_set(x_120, 3, x_112);
-lean_ctor_set_uint8(x_120, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_120);
+uint8_t x_109; 
+x_109 = lean_ctor_get_uint8(x_56, sizeof(void*)*4);
+if (x_109 == 0)
+{
+uint8_t x_110; 
+x_110 = !lean_is_exclusive(x_55);
+if (x_110 == 0)
+{
+lean_object* x_111; uint8_t x_112; 
+x_111 = lean_ctor_get(x_55, 0);
+lean_dec(x_111);
+x_112 = !lean_is_exclusive(x_56);
+if (x_112 == 0)
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint8_t x_117; uint8_t x_118; 
+x_113 = lean_ctor_get(x_56, 0);
+x_114 = lean_ctor_get(x_56, 1);
+x_115 = lean_ctor_get(x_56, 2);
+x_116 = lean_ctor_get(x_56, 3);
+x_117 = 1;
+lean_ctor_set(x_56, 3, x_113);
+lean_ctor_set(x_56, 2, x_44);
+lean_ctor_set(x_56, 1, x_43);
+lean_ctor_set(x_56, 0, x_42);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_117);
+lean_ctor_set(x_55, 0, x_116);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_117);
+x_118 = 0;
+lean_ctor_set(x_1, 3, x_55);
 lean_ctor_set(x_1, 2, x_115);
 lean_ctor_set(x_1, 1, x_114);
-lean_ctor_set(x_1, 0, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 0, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_118);
 return x_1;
 }
-}
 else
 {
-lean_object* x_121; 
-x_121 = lean_ctor_get(x_46, 3);
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; lean_object* x_124; uint8_t x_125; 
+x_119 = lean_ctor_get(x_56, 0);
+x_120 = lean_ctor_get(x_56, 1);
+x_121 = lean_ctor_get(x_56, 2);
+x_122 = lean_ctor_get(x_56, 3);
+lean_inc(x_122);
 lean_inc(x_121);
-if (lean_obj_tag(x_121) == 0)
-{
-uint8_t x_122; 
-x_122 = !lean_is_exclusive(x_46);
-if (x_122 == 0)
-{
-lean_object* x_123; lean_object* x_124; uint8_t x_125; 
-x_123 = lean_ctor_get(x_46, 3);
-lean_dec(x_123);
-x_124 = lean_ctor_get(x_46, 0);
-lean_dec(x_124);
+lean_inc(x_120);
+lean_inc(x_119);
+lean_dec(x_56);
+x_123 = 1;
+x_124 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_124, 0, x_42);
+lean_ctor_set(x_124, 1, x_43);
+lean_ctor_set(x_124, 2, x_44);
+lean_ctor_set(x_124, 3, x_119);
+lean_ctor_set_uint8(x_124, sizeof(void*)*4, x_123);
+lean_ctor_set(x_55, 0, x_122);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_123);
 x_125 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_125);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_124);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_125);
 return x_1;
 }
+}
 else
 {
-lean_object* x_126; lean_object* x_127; uint8_t x_128; lean_object* x_129; 
-x_126 = lean_ctor_get(x_46, 1);
-x_127 = lean_ctor_get(x_46, 2);
+lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; uint8_t x_137; 
+x_126 = lean_ctor_get(x_55, 1);
+x_127 = lean_ctor_get(x_55, 2);
+x_128 = lean_ctor_get(x_55, 3);
+lean_inc(x_128);
 lean_inc(x_127);
 lean_inc(x_126);
-lean_dec(x_46);
-x_128 = 0;
-x_129 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_129, 0, x_47);
-lean_ctor_set(x_129, 1, x_126);
-lean_ctor_set(x_129, 2, x_127);
-lean_ctor_set(x_129, 3, x_121);
-lean_ctor_set_uint8(x_129, sizeof(void*)*4, x_128);
-lean_ctor_set(x_1, 3, x_129);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_dec(x_55);
+x_129 = lean_ctor_get(x_56, 0);
+lean_inc(x_129);
+x_130 = lean_ctor_get(x_56, 1);
+lean_inc(x_130);
+x_131 = lean_ctor_get(x_56, 2);
+lean_inc(x_131);
+x_132 = lean_ctor_get(x_56, 3);
+lean_inc(x_132);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_133 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_133 = lean_box(0);
+}
+x_134 = 1;
+if (lean_is_scalar(x_133)) {
+ x_135 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_135 = x_133;
+}
+lean_ctor_set(x_135, 0, x_42);
+lean_ctor_set(x_135, 1, x_43);
+lean_ctor_set(x_135, 2, x_44);
+lean_ctor_set(x_135, 3, x_129);
+lean_ctor_set_uint8(x_135, sizeof(void*)*4, x_134);
+x_136 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_136, 0, x_132);
+lean_ctor_set(x_136, 1, x_126);
+lean_ctor_set(x_136, 2, x_127);
+lean_ctor_set(x_136, 3, x_128);
+lean_ctor_set_uint8(x_136, sizeof(void*)*4, x_134);
+x_137 = 0;
+lean_ctor_set(x_1, 3, x_136);
+lean_ctor_set(x_1, 2, x_131);
+lean_ctor_set(x_1, 1, x_130);
+lean_ctor_set(x_1, 0, x_135);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_137);
 return x_1;
 }
 }
 else
 {
-uint8_t x_130; 
-x_130 = lean_ctor_get_uint8(x_121, sizeof(void*)*4);
-if (x_130 == 0)
+lean_object* x_138; 
+x_138 = lean_ctor_get(x_55, 3);
+lean_inc(x_138);
+if (lean_obj_tag(x_138) == 0)
 {
-uint8_t x_131; 
-lean_free_object(x_1);
-x_131 = !lean_is_exclusive(x_46);
-if (x_131 == 0)
-{
-lean_object* x_132; lean_object* x_133; uint8_t x_134; 
-x_132 = lean_ctor_get(x_46, 3);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_46, 0);
-lean_dec(x_133);
-x_134 = !lean_is_exclusive(x_121);
-if (x_134 == 0)
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; 
-x_135 = lean_ctor_get(x_121, 0);
-x_136 = lean_ctor_get(x_121, 1);
-x_137 = lean_ctor_get(x_121, 2);
-x_138 = lean_ctor_get(x_121, 3);
-lean_inc(x_47);
-lean_ctor_set(x_121, 3, x_47);
-lean_ctor_set(x_121, 2, x_37);
-lean_ctor_set(x_121, 1, x_36);
-lean_ctor_set(x_121, 0, x_35);
-x_139 = !lean_is_exclusive(x_47);
+uint8_t x_139; 
+x_139 = !lean_is_exclusive(x_55);
 if (x_139 == 0)
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_140 = lean_ctor_get(x_47, 3);
+lean_object* x_140; lean_object* x_141; uint8_t x_142; uint8_t x_143; 
+x_140 = lean_ctor_get(x_55, 3);
 lean_dec(x_140);
-x_141 = lean_ctor_get(x_47, 2);
+x_141 = lean_ctor_get(x_55, 0);
 lean_dec(x_141);
-x_142 = lean_ctor_get(x_47, 1);
-lean_dec(x_142);
-x_143 = lean_ctor_get(x_47, 0);
-lean_dec(x_143);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-lean_ctor_set(x_47, 3, x_138);
-lean_ctor_set(x_47, 2, x_137);
-lean_ctor_set(x_47, 1, x_136);
-lean_ctor_set(x_47, 0, x_135);
-lean_ctor_set(x_46, 3, x_47);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-else
-{
-lean_object* x_144; 
-lean_dec(x_47);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-x_144 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_144, 0, x_135);
-lean_ctor_set(x_144, 1, x_136);
-lean_ctor_set(x_144, 2, x_137);
-lean_ctor_set(x_144, 3, x_138);
-lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_144);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
-x_145 = lean_ctor_get(x_121, 0);
-x_146 = lean_ctor_get(x_121, 1);
-x_147 = lean_ctor_get(x_121, 2);
-x_148 = lean_ctor_get(x_121, 3);
-lean_inc(x_148);
-lean_inc(x_147);
-lean_inc(x_146);
-lean_inc(x_145);
-lean_dec(x_121);
-lean_inc(x_47);
-x_149 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_149, 0, x_35);
-lean_ctor_set(x_149, 1, x_36);
-lean_ctor_set(x_149, 2, x_37);
-lean_ctor_set(x_149, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_150 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_145);
-lean_ctor_set(x_151, 1, x_146);
-lean_ctor_set(x_151, 2, x_147);
-lean_ctor_set(x_151, 3, x_148);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_151);
-lean_ctor_set(x_46, 0, x_149);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
-x_152 = lean_ctor_get(x_46, 1);
-x_153 = lean_ctor_get(x_46, 2);
-lean_inc(x_153);
-lean_inc(x_152);
-lean_dec(x_46);
-x_154 = lean_ctor_get(x_121, 0);
-lean_inc(x_154);
-x_155 = lean_ctor_get(x_121, 1);
-lean_inc(x_155);
-x_156 = lean_ctor_get(x_121, 2);
-lean_inc(x_156);
-x_157 = lean_ctor_get(x_121, 3);
-lean_inc(x_157);
-if (lean_is_exclusive(x_121)) {
- lean_ctor_release(x_121, 0);
- lean_ctor_release(x_121, 1);
- lean_ctor_release(x_121, 2);
- lean_ctor_release(x_121, 3);
- x_158 = x_121;
-} else {
- lean_dec_ref(x_121);
- x_158 = lean_box(0);
-}
-lean_inc(x_47);
-if (lean_is_scalar(x_158)) {
- x_159 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_159 = x_158;
-}
-lean_ctor_set(x_159, 0, x_35);
-lean_ctor_set(x_159, 1, x_36);
-lean_ctor_set(x_159, 2, x_37);
-lean_ctor_set(x_159, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_160 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_160 = lean_box(0);
-}
-lean_ctor_set_uint8(x_159, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_160)) {
- x_161 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_161 = x_160;
-}
-lean_ctor_set(x_161, 0, x_154);
-lean_ctor_set(x_161, 1, x_155);
-lean_ctor_set(x_161, 2, x_156);
-lean_ctor_set(x_161, 3, x_157);
-lean_ctor_set_uint8(x_161, sizeof(void*)*4, x_95);
-x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_159);
-lean_ctor_set(x_162, 1, x_152);
-lean_ctor_set(x_162, 2, x_153);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_130);
-return x_162;
-}
-}
-else
-{
-uint8_t x_163; 
-x_163 = !lean_is_exclusive(x_46);
-if (x_163 == 0)
-{
-lean_object* x_164; lean_object* x_165; uint8_t x_166; 
-x_164 = lean_ctor_get(x_46, 3);
-lean_dec(x_164);
-x_165 = lean_ctor_get(x_46, 0);
-lean_dec(x_165);
-x_166 = !lean_is_exclusive(x_47);
-if (x_166 == 0)
-{
-uint8_t x_167; 
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_130);
-x_167 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_167);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
+x_142 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_142);
+x_143 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_143);
 return x_1;
 }
 else
 {
-lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; 
-x_168 = lean_ctor_get(x_47, 0);
-x_169 = lean_ctor_get(x_47, 1);
-x_170 = lean_ctor_get(x_47, 2);
-x_171 = lean_ctor_get(x_47, 3);
-lean_inc(x_171);
+lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; uint8_t x_148; 
+x_144 = lean_ctor_get(x_55, 1);
+x_145 = lean_ctor_get(x_55, 2);
+lean_inc(x_145);
+lean_inc(x_144);
+lean_dec(x_55);
+x_146 = 0;
+x_147 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_147, 0, x_56);
+lean_ctor_set(x_147, 1, x_144);
+lean_ctor_set(x_147, 2, x_145);
+lean_ctor_set(x_147, 3, x_138);
+lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_146);
+x_148 = 1;
+lean_ctor_set(x_1, 3, x_147);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_148);
+return x_1;
+}
+}
+else
+{
+uint8_t x_149; 
+x_149 = lean_ctor_get_uint8(x_138, sizeof(void*)*4);
+if (x_149 == 0)
+{
+uint8_t x_150; 
+lean_free_object(x_1);
+x_150 = !lean_is_exclusive(x_55);
+if (x_150 == 0)
+{
+lean_object* x_151; lean_object* x_152; uint8_t x_153; 
+x_151 = lean_ctor_get(x_55, 3);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_55, 0);
+lean_dec(x_152);
+x_153 = !lean_is_exclusive(x_138);
+if (x_153 == 0)
+{
+lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; uint8_t x_158; uint8_t x_159; 
+x_154 = lean_ctor_get(x_138, 0);
+x_155 = lean_ctor_get(x_138, 1);
+x_156 = lean_ctor_get(x_138, 2);
+x_157 = lean_ctor_get(x_138, 3);
+x_158 = 1;
+lean_inc(x_56);
+lean_ctor_set(x_138, 3, x_56);
+lean_ctor_set(x_138, 2, x_44);
+lean_ctor_set(x_138, 1, x_43);
+lean_ctor_set(x_138, 0, x_42);
+x_159 = !lean_is_exclusive(x_56);
+if (x_159 == 0)
+{
+lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; uint8_t x_164; 
+x_160 = lean_ctor_get(x_56, 3);
+lean_dec(x_160);
+x_161 = lean_ctor_get(x_56, 2);
+lean_dec(x_161);
+x_162 = lean_ctor_get(x_56, 1);
+lean_dec(x_162);
+x_163 = lean_ctor_get(x_56, 0);
+lean_dec(x_163);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+lean_ctor_set(x_56, 3, x_157);
+lean_ctor_set(x_56, 2, x_156);
+lean_ctor_set(x_56, 1, x_155);
+lean_ctor_set(x_56, 0, x_154);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_158);
+x_164 = 0;
+lean_ctor_set(x_55, 3, x_56);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_164);
+return x_55;
+}
+else
+{
+lean_object* x_165; uint8_t x_166; 
+lean_dec(x_56);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+x_165 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_165, 0, x_154);
+lean_ctor_set(x_165, 1, x_155);
+lean_ctor_set(x_165, 2, x_156);
+lean_ctor_set(x_165, 3, x_157);
+lean_ctor_set_uint8(x_165, sizeof(void*)*4, x_158);
+x_166 = 0;
+lean_ctor_set(x_55, 3, x_165);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_166);
+return x_55;
+}
+}
+else
+{
+lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; 
+x_167 = lean_ctor_get(x_138, 0);
+x_168 = lean_ctor_get(x_138, 1);
+x_169 = lean_ctor_get(x_138, 2);
+x_170 = lean_ctor_get(x_138, 3);
 lean_inc(x_170);
 lean_inc(x_169);
 lean_inc(x_168);
-lean_dec(x_47);
+lean_inc(x_167);
+lean_dec(x_138);
+x_171 = 1;
+lean_inc(x_56);
 x_172 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_172, 0, x_168);
-lean_ctor_set(x_172, 1, x_169);
-lean_ctor_set(x_172, 2, x_170);
-lean_ctor_set(x_172, 3, x_171);
-lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_130);
-x_173 = 0;
-lean_ctor_set(x_46, 0, x_172);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_173);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
+lean_ctor_set(x_172, 0, x_42);
+lean_ctor_set(x_172, 1, x_43);
+lean_ctor_set(x_172, 2, x_44);
+lean_ctor_set(x_172, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_173 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_173 = lean_box(0);
+}
+lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_171);
+if (lean_is_scalar(x_173)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_174 = x_173;
+}
+lean_ctor_set(x_174, 0, x_167);
+lean_ctor_set(x_174, 1, x_168);
+lean_ctor_set(x_174, 2, x_169);
+lean_ctor_set(x_174, 3, x_170);
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_171);
+x_175 = 0;
+lean_ctor_set(x_55, 3, x_174);
+lean_ctor_set(x_55, 0, x_172);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_175);
+return x_55;
 }
 }
 else
 {
-lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; uint8_t x_182; lean_object* x_183; 
-x_174 = lean_ctor_get(x_46, 1);
-x_175 = lean_ctor_get(x_46, 2);
-lean_inc(x_175);
-lean_inc(x_174);
-lean_dec(x_46);
-x_176 = lean_ctor_get(x_47, 0);
-lean_inc(x_176);
-x_177 = lean_ctor_get(x_47, 1);
+lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; uint8_t x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; uint8_t x_187; lean_object* x_188; 
+x_176 = lean_ctor_get(x_55, 1);
+x_177 = lean_ctor_get(x_55, 2);
 lean_inc(x_177);
-x_178 = lean_ctor_get(x_47, 2);
+lean_inc(x_176);
+lean_dec(x_55);
+x_178 = lean_ctor_get(x_138, 0);
 lean_inc(x_178);
-x_179 = lean_ctor_get(x_47, 3);
+x_179 = lean_ctor_get(x_138, 1);
 lean_inc(x_179);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_180 = x_47;
+x_180 = lean_ctor_get(x_138, 2);
+lean_inc(x_180);
+x_181 = lean_ctor_get(x_138, 3);
+lean_inc(x_181);
+if (lean_is_exclusive(x_138)) {
+ lean_ctor_release(x_138, 0);
+ lean_ctor_release(x_138, 1);
+ lean_ctor_release(x_138, 2);
+ lean_ctor_release(x_138, 3);
+ x_182 = x_138;
 } else {
- lean_dec_ref(x_47);
- x_180 = lean_box(0);
+ lean_dec_ref(x_138);
+ x_182 = lean_box(0);
 }
-if (lean_is_scalar(x_180)) {
- x_181 = lean_alloc_ctor(1, 4, 1);
+x_183 = 1;
+lean_inc(x_56);
+if (lean_is_scalar(x_182)) {
+ x_184 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_181 = x_180;
-}
-lean_ctor_set(x_181, 0, x_176);
-lean_ctor_set(x_181, 1, x_177);
-lean_ctor_set(x_181, 2, x_178);
-lean_ctor_set(x_181, 3, x_179);
-lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_130);
-x_182 = 0;
-x_183 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_183, 0, x_181);
-lean_ctor_set(x_183, 1, x_174);
-lean_ctor_set(x_183, 2, x_175);
-lean_ctor_set(x_183, 3, x_121);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_182);
-lean_ctor_set(x_1, 3, x_183);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
-}
-}
-}
+ x_184 = x_182;
 }
+lean_ctor_set(x_184, 0, x_42);
+lean_ctor_set(x_184, 1, x_43);
+lean_ctor_set(x_184, 2, x_44);
+lean_ctor_set(x_184, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_185 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_185 = lean_box(0);
 }
+lean_ctor_set_uint8(x_184, sizeof(void*)*4, x_183);
+if (lean_is_scalar(x_185)) {
+ x_186 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_186 = x_185;
 }
+lean_ctor_set(x_186, 0, x_178);
+lean_ctor_set(x_186, 1, x_179);
+lean_ctor_set(x_186, 2, x_180);
+lean_ctor_set(x_186, 3, x_181);
+lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_183);
+x_187 = 0;
+x_188 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_188, 0, x_184);
+lean_ctor_set(x_188, 1, x_176);
+lean_ctor_set(x_188, 2, x_177);
+lean_ctor_set(x_188, 3, x_186);
+lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_187);
+return x_188;
 }
 }
 else
 {
-uint8_t x_184; 
-x_184 = l_Std_RBNode_isRed___rarg(x_35);
-if (x_184 == 0)
-{
-lean_object* x_185; 
-x_185 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_35, x_2, x_3);
-lean_ctor_set(x_1, 0, x_185);
-return x_1;
-}
-else
-{
-lean_object* x_186; lean_object* x_187; 
-x_186 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_35, x_2, x_3);
-x_187 = lean_ctor_get(x_186, 0);
-lean_inc(x_187);
-if (lean_obj_tag(x_187) == 0)
-{
-lean_object* x_188; 
-x_188 = lean_ctor_get(x_186, 3);
-lean_inc(x_188);
-if (lean_obj_tag(x_188) == 0)
-{
 uint8_t x_189; 
-x_189 = !lean_is_exclusive(x_186);
+x_189 = !lean_is_exclusive(x_55);
 if (x_189 == 0)
 {
-lean_object* x_190; lean_object* x_191; uint8_t x_192; uint8_t x_193; 
-x_190 = lean_ctor_get(x_186, 3);
+lean_object* x_190; lean_object* x_191; uint8_t x_192; 
+x_190 = lean_ctor_get(x_55, 3);
 lean_dec(x_190);
-x_191 = lean_ctor_get(x_186, 0);
+x_191 = lean_ctor_get(x_55, 0);
 lean_dec(x_191);
-x_192 = 0;
-lean_ctor_set(x_186, 0, x_188);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_192);
-x_193 = 1;
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_193);
+x_192 = !lean_is_exclusive(x_56);
+if (x_192 == 0)
+{
+uint8_t x_193; uint8_t x_194; 
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_149);
+x_193 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_193);
+x_194 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_194);
 return x_1;
 }
 else
 {
-lean_object* x_194; lean_object* x_195; uint8_t x_196; lean_object* x_197; uint8_t x_198; 
-x_194 = lean_ctor_get(x_186, 1);
-x_195 = lean_ctor_get(x_186, 2);
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; uint8_t x_201; 
+x_195 = lean_ctor_get(x_56, 0);
+x_196 = lean_ctor_get(x_56, 1);
+x_197 = lean_ctor_get(x_56, 2);
+x_198 = lean_ctor_get(x_56, 3);
+lean_inc(x_198);
+lean_inc(x_197);
+lean_inc(x_196);
 lean_inc(x_195);
-lean_inc(x_194);
-lean_dec(x_186);
-x_196 = 0;
-x_197 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_197, 0, x_188);
-lean_ctor_set(x_197, 1, x_194);
-lean_ctor_set(x_197, 2, x_195);
-lean_ctor_set(x_197, 3, x_188);
-lean_ctor_set_uint8(x_197, sizeof(void*)*4, x_196);
-x_198 = 1;
-lean_ctor_set(x_1, 0, x_197);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_198);
+lean_dec(x_56);
+x_199 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_199, 0, x_195);
+lean_ctor_set(x_199, 1, x_196);
+lean_ctor_set(x_199, 2, x_197);
+lean_ctor_set(x_199, 3, x_198);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_149);
+x_200 = 0;
+lean_ctor_set(x_55, 0, x_199);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_200);
+x_201 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_201);
 return x_1;
 }
 }
 else
 {
-uint8_t x_199; 
-x_199 = lean_ctor_get_uint8(x_188, sizeof(void*)*4);
-if (x_199 == 0)
-{
-uint8_t x_200; 
-x_200 = !lean_is_exclusive(x_186);
-if (x_200 == 0)
-{
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; 
-x_201 = lean_ctor_get(x_186, 1);
-x_202 = lean_ctor_get(x_186, 2);
-x_203 = lean_ctor_get(x_186, 3);
-lean_dec(x_203);
-x_204 = lean_ctor_get(x_186, 0);
-lean_dec(x_204);
-x_205 = !lean_is_exclusive(x_188);
-if (x_205 == 0)
-{
-lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; 
-x_206 = lean_ctor_get(x_188, 0);
-x_207 = lean_ctor_get(x_188, 1);
-x_208 = lean_ctor_get(x_188, 2);
-x_209 = lean_ctor_get(x_188, 3);
-x_210 = 1;
-lean_ctor_set(x_188, 3, x_206);
-lean_ctor_set(x_188, 2, x_202);
-lean_ctor_set(x_188, 1, x_201);
-lean_ctor_set(x_188, 0, x_187);
-lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_210);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_209);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_210);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_208);
-lean_ctor_set(x_1, 1, x_207);
-lean_ctor_set(x_1, 0, x_188);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; lean_object* x_211; uint8_t x_212; 
+x_202 = lean_ctor_get(x_55, 1);
+x_203 = lean_ctor_get(x_55, 2);
+lean_inc(x_203);
+lean_inc(x_202);
+lean_dec(x_55);
+x_204 = lean_ctor_get(x_56, 0);
+lean_inc(x_204);
+x_205 = lean_ctor_get(x_56, 1);
+lean_inc(x_205);
+x_206 = lean_ctor_get(x_56, 2);
+lean_inc(x_206);
+x_207 = lean_ctor_get(x_56, 3);
+lean_inc(x_207);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_208 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_208 = lean_box(0);
+}
+if (lean_is_scalar(x_208)) {
+ x_209 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_209 = x_208;
+}
+lean_ctor_set(x_209, 0, x_204);
+lean_ctor_set(x_209, 1, x_205);
+lean_ctor_set(x_209, 2, x_206);
+lean_ctor_set(x_209, 3, x_207);
+lean_ctor_set_uint8(x_209, sizeof(void*)*4, x_149);
+x_210 = 0;
+x_211 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_211, 0, x_209);
+lean_ctor_set(x_211, 1, x_202);
+lean_ctor_set(x_211, 2, x_203);
+lean_ctor_set(x_211, 3, x_138);
+lean_ctor_set_uint8(x_211, sizeof(void*)*4, x_210);
+x_212 = 1;
+lean_ctor_set(x_1, 3, x_211);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_212);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; uint8_t x_215; lean_object* x_216; 
-x_211 = lean_ctor_get(x_188, 0);
-x_212 = lean_ctor_get(x_188, 1);
-x_213 = lean_ctor_get(x_188, 2);
-x_214 = lean_ctor_get(x_188, 3);
-lean_inc(x_214);
-lean_inc(x_213);
-lean_inc(x_212);
-lean_inc(x_211);
-lean_dec(x_188);
+uint8_t x_213; 
+x_213 = l_Std_RBNode_isRed___rarg(x_42);
+if (x_213 == 0)
+{
+lean_object* x_214; uint8_t x_215; 
+x_214 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_42, x_2, x_3);
 x_215 = 1;
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_187);
-lean_ctor_set(x_216, 1, x_201);
-lean_ctor_set(x_216, 2, x_202);
-lean_ctor_set(x_216, 3, x_211);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_215);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_214);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_215);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_213);
-lean_ctor_set(x_1, 1, x_212);
-lean_ctor_set(x_1, 0, x_216);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_ctor_set(x_1, 0, x_214);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_215);
 return x_1;
 }
-}
 else
 {
-lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; uint8_t x_224; lean_object* x_225; lean_object* x_226; 
-x_217 = lean_ctor_get(x_186, 1);
-x_218 = lean_ctor_get(x_186, 2);
-lean_inc(x_218);
+lean_object* x_216; lean_object* x_217; 
+x_216 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_42, x_2, x_3);
+x_217 = lean_ctor_get(x_216, 0);
 lean_inc(x_217);
-lean_dec(x_186);
-x_219 = lean_ctor_get(x_188, 0);
-lean_inc(x_219);
-x_220 = lean_ctor_get(x_188, 1);
-lean_inc(x_220);
-x_221 = lean_ctor_get(x_188, 2);
-lean_inc(x_221);
-x_222 = lean_ctor_get(x_188, 3);
-lean_inc(x_222);
-if (lean_is_exclusive(x_188)) {
- lean_ctor_release(x_188, 0);
- lean_ctor_release(x_188, 1);
- lean_ctor_release(x_188, 2);
- lean_ctor_release(x_188, 3);
- x_223 = x_188;
-} else {
- lean_dec_ref(x_188);
- x_223 = lean_box(0);
+if (lean_obj_tag(x_217) == 0)
+{
+lean_object* x_218; 
+x_218 = lean_ctor_get(x_216, 3);
+lean_inc(x_218);
+if (lean_obj_tag(x_218) == 0)
+{
+uint8_t x_219; 
+x_219 = !lean_is_exclusive(x_216);
+if (x_219 == 0)
+{
+lean_object* x_220; lean_object* x_221; uint8_t x_222; uint8_t x_223; 
+x_220 = lean_ctor_get(x_216, 3);
+lean_dec(x_220);
+x_221 = lean_ctor_get(x_216, 0);
+lean_dec(x_221);
+x_222 = 0;
+lean_ctor_set(x_216, 0, x_218);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_222);
+x_223 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_223);
+return x_1;
 }
-x_224 = 1;
-if (lean_is_scalar(x_223)) {
- x_225 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_225 = x_223;
-}
-lean_ctor_set(x_225, 0, x_187);
-lean_ctor_set(x_225, 1, x_217);
-lean_ctor_set(x_225, 2, x_218);
-lean_ctor_set(x_225, 3, x_219);
-lean_ctor_set_uint8(x_225, sizeof(void*)*4, x_224);
-x_226 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_226, 0, x_222);
-lean_ctor_set(x_226, 1, x_36);
-lean_ctor_set(x_226, 2, x_37);
-lean_ctor_set(x_226, 3, x_38);
-lean_ctor_set_uint8(x_226, sizeof(void*)*4, x_224);
-lean_ctor_set(x_1, 3, x_226);
-lean_ctor_set(x_1, 2, x_221);
-lean_ctor_set(x_1, 1, x_220);
-lean_ctor_set(x_1, 0, x_225);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+else
+{
+lean_object* x_224; lean_object* x_225; uint8_t x_226; lean_object* x_227; uint8_t x_228; 
+x_224 = lean_ctor_get(x_216, 1);
+x_225 = lean_ctor_get(x_216, 2);
+lean_inc(x_225);
+lean_inc(x_224);
+lean_dec(x_216);
+x_226 = 0;
+x_227 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_227, 0, x_218);
+lean_ctor_set(x_227, 1, x_224);
+lean_ctor_set(x_227, 2, x_225);
+lean_ctor_set(x_227, 3, x_218);
+lean_ctor_set_uint8(x_227, sizeof(void*)*4, x_226);
+x_228 = 1;
+lean_ctor_set(x_1, 0, x_227);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_228);
 return x_1;
 }
 }
 else
 {
-uint8_t x_227; 
-x_227 = !lean_is_exclusive(x_186);
-if (x_227 == 0)
+uint8_t x_229; 
+x_229 = lean_ctor_get_uint8(x_218, sizeof(void*)*4);
+if (x_229 == 0)
 {
-lean_object* x_228; lean_object* x_229; uint8_t x_230; 
-x_228 = lean_ctor_get(x_186, 3);
-lean_dec(x_228);
-x_229 = lean_ctor_get(x_186, 0);
-lean_dec(x_229);
-x_230 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_230);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-else
+uint8_t x_230; 
+x_230 = !lean_is_exclusive(x_216);
+if (x_230 == 0)
 {
-lean_object* x_231; lean_object* x_232; uint8_t x_233; lean_object* x_234; 
-x_231 = lean_ctor_get(x_186, 1);
-x_232 = lean_ctor_get(x_186, 2);
-lean_inc(x_232);
-lean_inc(x_231);
-lean_dec(x_186);
-x_233 = 0;
-x_234 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_234, 0, x_187);
-lean_ctor_set(x_234, 1, x_231);
-lean_ctor_set(x_234, 2, x_232);
-lean_ctor_set(x_234, 3, x_188);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_233);
-lean_ctor_set(x_1, 0, x_234);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_235; 
-x_235 = lean_ctor_get_uint8(x_187, sizeof(void*)*4);
+lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; uint8_t x_235; 
+x_231 = lean_ctor_get(x_216, 1);
+x_232 = lean_ctor_get(x_216, 2);
+x_233 = lean_ctor_get(x_216, 3);
+lean_dec(x_233);
+x_234 = lean_ctor_get(x_216, 0);
+lean_dec(x_234);
+x_235 = !lean_is_exclusive(x_218);
 if (x_235 == 0)
 {
-uint8_t x_236; 
-x_236 = !lean_is_exclusive(x_186);
-if (x_236 == 0)
-{
-lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; uint8_t x_241; 
-x_237 = lean_ctor_get(x_186, 1);
-x_238 = lean_ctor_get(x_186, 2);
-x_239 = lean_ctor_get(x_186, 3);
-x_240 = lean_ctor_get(x_186, 0);
-lean_dec(x_240);
-x_241 = !lean_is_exclusive(x_187);
-if (x_241 == 0)
-{
-uint8_t x_242; 
-x_242 = 1;
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_242);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_242);
-lean_ctor_set(x_1, 3, x_186);
+lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; uint8_t x_240; uint8_t x_241; 
+x_236 = lean_ctor_get(x_218, 0);
+x_237 = lean_ctor_get(x_218, 1);
+x_238 = lean_ctor_get(x_218, 2);
+x_239 = lean_ctor_get(x_218, 3);
+x_240 = 1;
+lean_ctor_set(x_218, 3, x_236);
+lean_ctor_set(x_218, 2, x_232);
+lean_ctor_set(x_218, 1, x_231);
+lean_ctor_set(x_218, 0, x_217);
+lean_ctor_set_uint8(x_218, sizeof(void*)*4, x_240);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_239);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_240);
+x_241 = 0;
+lean_ctor_set(x_1, 3, x_216);
 lean_ctor_set(x_1, 2, x_238);
 lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_1, 0, x_218);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_241);
 return x_1;
 }
 else
 {
-lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; 
-x_243 = lean_ctor_get(x_187, 0);
-x_244 = lean_ctor_get(x_187, 1);
-x_245 = lean_ctor_get(x_187, 2);
-x_246 = lean_ctor_get(x_187, 3);
-lean_inc(x_246);
+lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; uint8_t x_248; 
+x_242 = lean_ctor_get(x_218, 0);
+x_243 = lean_ctor_get(x_218, 1);
+x_244 = lean_ctor_get(x_218, 2);
+x_245 = lean_ctor_get(x_218, 3);
 lean_inc(x_245);
 lean_inc(x_244);
 lean_inc(x_243);
-lean_dec(x_187);
-x_247 = 1;
-x_248 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_248, 0, x_243);
-lean_ctor_set(x_248, 1, x_244);
-lean_ctor_set(x_248, 2, x_245);
-lean_ctor_set(x_248, 3, x_246);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_238);
-lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_inc(x_242);
+lean_dec(x_218);
+x_246 = 1;
+x_247 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_247, 0, x_217);
+lean_ctor_set(x_247, 1, x_231);
+lean_ctor_set(x_247, 2, x_232);
+lean_ctor_set(x_247, 3, x_242);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_245);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_246);
+x_248 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_244);
+lean_ctor_set(x_1, 1, x_243);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_248);
 return x_1;
 }
 }
 else
 {
-lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; lean_object* x_259; 
-x_249 = lean_ctor_get(x_186, 1);
-x_250 = lean_ctor_get(x_186, 2);
-x_251 = lean_ctor_get(x_186, 3);
-lean_inc(x_251);
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; lean_object* x_257; lean_object* x_258; uint8_t x_259; 
+x_249 = lean_ctor_get(x_216, 1);
+x_250 = lean_ctor_get(x_216, 2);
 lean_inc(x_250);
 lean_inc(x_249);
-lean_dec(x_186);
-x_252 = lean_ctor_get(x_187, 0);
+lean_dec(x_216);
+x_251 = lean_ctor_get(x_218, 0);
+lean_inc(x_251);
+x_252 = lean_ctor_get(x_218, 1);
 lean_inc(x_252);
-x_253 = lean_ctor_get(x_187, 1);
+x_253 = lean_ctor_get(x_218, 2);
 lean_inc(x_253);
-x_254 = lean_ctor_get(x_187, 2);
+x_254 = lean_ctor_get(x_218, 3);
 lean_inc(x_254);
-x_255 = lean_ctor_get(x_187, 3);
-lean_inc(x_255);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_256 = x_187;
+if (lean_is_exclusive(x_218)) {
+ lean_ctor_release(x_218, 0);
+ lean_ctor_release(x_218, 1);
+ lean_ctor_release(x_218, 2);
+ lean_ctor_release(x_218, 3);
+ x_255 = x_218;
 } else {
- lean_dec_ref(x_187);
- x_256 = lean_box(0);
+ lean_dec_ref(x_218);
+ x_255 = lean_box(0);
 }
-x_257 = 1;
-if (lean_is_scalar(x_256)) {
- x_258 = lean_alloc_ctor(1, 4, 1);
+x_256 = 1;
+if (lean_is_scalar(x_255)) {
+ x_257 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_258 = x_256;
+ x_257 = x_255;
 }
-lean_ctor_set(x_258, 0, x_252);
-lean_ctor_set(x_258, 1, x_253);
-lean_ctor_set(x_258, 2, x_254);
-lean_ctor_set(x_258, 3, x_255);
-lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
-x_259 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_259, 0, x_251);
-lean_ctor_set(x_259, 1, x_36);
-lean_ctor_set(x_259, 2, x_37);
-lean_ctor_set(x_259, 3, x_38);
-lean_ctor_set_uint8(x_259, sizeof(void*)*4, x_257);
-lean_ctor_set(x_1, 3, x_259);
-lean_ctor_set(x_1, 2, x_250);
-lean_ctor_set(x_1, 1, x_249);
-lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_257, 0, x_217);
+lean_ctor_set(x_257, 1, x_249);
+lean_ctor_set(x_257, 2, x_250);
+lean_ctor_set(x_257, 3, x_251);
+lean_ctor_set_uint8(x_257, sizeof(void*)*4, x_256);
+x_258 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_258, 0, x_254);
+lean_ctor_set(x_258, 1, x_43);
+lean_ctor_set(x_258, 2, x_44);
+lean_ctor_set(x_258, 3, x_45);
+lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_256);
+x_259 = 0;
+lean_ctor_set(x_1, 3, x_258);
+lean_ctor_set(x_1, 2, x_253);
+lean_ctor_set(x_1, 1, x_252);
+lean_ctor_set(x_1, 0, x_257);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
 return x_1;
 }
 }
 else
 {
-lean_object* x_260; 
-x_260 = lean_ctor_get(x_186, 3);
-lean_inc(x_260);
-if (lean_obj_tag(x_260) == 0)
+uint8_t x_260; 
+x_260 = !lean_is_exclusive(x_216);
+if (x_260 == 0)
 {
-uint8_t x_261; 
-x_261 = !lean_is_exclusive(x_186);
-if (x_261 == 0)
-{
-lean_object* x_262; lean_object* x_263; uint8_t x_264; 
-x_262 = lean_ctor_get(x_186, 3);
+lean_object* x_261; lean_object* x_262; uint8_t x_263; uint8_t x_264; 
+x_261 = lean_ctor_get(x_216, 3);
+lean_dec(x_261);
+x_262 = lean_ctor_get(x_216, 0);
 lean_dec(x_262);
-x_263 = lean_ctor_get(x_186, 0);
-lean_dec(x_263);
-x_264 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_264);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+x_263 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_263);
+x_264 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_264);
 return x_1;
 }
 else
 {
-lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; 
-x_265 = lean_ctor_get(x_186, 1);
-x_266 = lean_ctor_get(x_186, 2);
+lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; uint8_t x_269; 
+x_265 = lean_ctor_get(x_216, 1);
+x_266 = lean_ctor_get(x_216, 2);
 lean_inc(x_266);
 lean_inc(x_265);
-lean_dec(x_186);
+lean_dec(x_216);
 x_267 = 0;
 x_268 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_268, 0, x_187);
+lean_ctor_set(x_268, 0, x_217);
 lean_ctor_set(x_268, 1, x_265);
 lean_ctor_set(x_268, 2, x_266);
-lean_ctor_set(x_268, 3, x_260);
+lean_ctor_set(x_268, 3, x_218);
 lean_ctor_set_uint8(x_268, sizeof(void*)*4, x_267);
+x_269 = 1;
 lean_ctor_set(x_1, 0, x_268);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_270; 
+x_270 = lean_ctor_get_uint8(x_217, sizeof(void*)*4);
+if (x_270 == 0)
+{
+uint8_t x_271; 
+x_271 = !lean_is_exclusive(x_216);
+if (x_271 == 0)
+{
+lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; uint8_t x_276; 
+x_272 = lean_ctor_get(x_216, 1);
+x_273 = lean_ctor_get(x_216, 2);
+x_274 = lean_ctor_get(x_216, 3);
+x_275 = lean_ctor_get(x_216, 0);
+lean_dec(x_275);
+x_276 = !lean_is_exclusive(x_217);
+if (x_276 == 0)
+{
+uint8_t x_277; uint8_t x_278; 
+x_277 = 1;
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_277);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_277);
+x_278 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_278);
+return x_1;
+}
+else
+{
+lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; uint8_t x_283; lean_object* x_284; uint8_t x_285; 
+x_279 = lean_ctor_get(x_217, 0);
+x_280 = lean_ctor_get(x_217, 1);
+x_281 = lean_ctor_get(x_217, 2);
+x_282 = lean_ctor_get(x_217, 3);
+lean_inc(x_282);
+lean_inc(x_281);
+lean_inc(x_280);
+lean_inc(x_279);
+lean_dec(x_217);
+x_283 = 1;
+x_284 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_284, 0, x_279);
+lean_ctor_set(x_284, 1, x_280);
+lean_ctor_set(x_284, 2, x_281);
+lean_ctor_set(x_284, 3, x_282);
+lean_ctor_set_uint8(x_284, sizeof(void*)*4, x_283);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_283);
+x_285 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_284);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_285);
 return x_1;
 }
 }
 else
 {
-uint8_t x_269; 
-x_269 = lean_ctor_get_uint8(x_260, sizeof(void*)*4);
-if (x_269 == 0)
-{
-uint8_t x_270; 
-lean_free_object(x_1);
-x_270 = !lean_is_exclusive(x_186);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; uint8_t x_275; 
-x_271 = lean_ctor_get(x_186, 1);
-x_272 = lean_ctor_get(x_186, 2);
-x_273 = lean_ctor_get(x_186, 3);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_186, 0);
-lean_dec(x_274);
-x_275 = !lean_is_exclusive(x_260);
-if (x_275 == 0)
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; uint8_t x_280; 
-x_276 = lean_ctor_get(x_260, 0);
-x_277 = lean_ctor_get(x_260, 1);
-x_278 = lean_ctor_get(x_260, 2);
-x_279 = lean_ctor_get(x_260, 3);
-lean_inc(x_187);
-lean_ctor_set(x_260, 3, x_276);
-lean_ctor_set(x_260, 2, x_272);
-lean_ctor_set(x_260, 1, x_271);
-lean_ctor_set(x_260, 0, x_187);
-x_280 = !lean_is_exclusive(x_187);
-if (x_280 == 0)
-{
-lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; 
-x_281 = lean_ctor_get(x_187, 3);
-lean_dec(x_281);
-x_282 = lean_ctor_get(x_187, 2);
-lean_dec(x_282);
-x_283 = lean_ctor_get(x_187, 1);
-lean_dec(x_283);
-x_284 = lean_ctor_get(x_187, 0);
-lean_dec(x_284);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-lean_ctor_set(x_187, 3, x_38);
-lean_ctor_set(x_187, 2, x_37);
-lean_ctor_set(x_187, 1, x_36);
-lean_ctor_set(x_187, 0, x_279);
-lean_ctor_set(x_186, 3, x_187);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-else
-{
-lean_object* x_285; 
-lean_dec(x_187);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-x_285 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_285, 0, x_279);
-lean_ctor_set(x_285, 1, x_36);
-lean_ctor_set(x_285, 2, x_37);
-lean_ctor_set(x_285, 3, x_38);
-lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_285);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-}
-else
-{
-lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; 
-x_286 = lean_ctor_get(x_260, 0);
-x_287 = lean_ctor_get(x_260, 1);
-x_288 = lean_ctor_get(x_260, 2);
-x_289 = lean_ctor_get(x_260, 3);
-lean_inc(x_289);
+lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; uint8_t x_294; lean_object* x_295; lean_object* x_296; uint8_t x_297; 
+x_286 = lean_ctor_get(x_216, 1);
+x_287 = lean_ctor_get(x_216, 2);
+x_288 = lean_ctor_get(x_216, 3);
 lean_inc(x_288);
 lean_inc(x_287);
 lean_inc(x_286);
-lean_dec(x_260);
-lean_inc(x_187);
-x_290 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_290, 0, x_187);
-lean_ctor_set(x_290, 1, x_271);
-lean_ctor_set(x_290, 2, x_272);
-lean_ctor_set(x_290, 3, x_286);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_291 = x_187;
+lean_dec(x_216);
+x_289 = lean_ctor_get(x_217, 0);
+lean_inc(x_289);
+x_290 = lean_ctor_get(x_217, 1);
+lean_inc(x_290);
+x_291 = lean_ctor_get(x_217, 2);
+lean_inc(x_291);
+x_292 = lean_ctor_get(x_217, 3);
+lean_inc(x_292);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_293 = x_217;
 } else {
- lean_dec_ref(x_187);
- x_291 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_293 = lean_box(0);
 }
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
+x_294 = 1;
+if (lean_is_scalar(x_293)) {
+ x_295 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_292 = x_291;
+ x_295 = x_293;
 }
-lean_ctor_set(x_292, 0, x_289);
-lean_ctor_set(x_292, 1, x_36);
-lean_ctor_set(x_292, 2, x_37);
-lean_ctor_set(x_292, 3, x_38);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_292);
-lean_ctor_set(x_186, 2, x_288);
-lean_ctor_set(x_186, 1, x_287);
-lean_ctor_set(x_186, 0, x_290);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
+lean_ctor_set(x_295, 0, x_289);
+lean_ctor_set(x_295, 1, x_290);
+lean_ctor_set(x_295, 2, x_291);
+lean_ctor_set(x_295, 3, x_292);
+lean_ctor_set_uint8(x_295, sizeof(void*)*4, x_294);
+x_296 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_296, 0, x_288);
+lean_ctor_set(x_296, 1, x_43);
+lean_ctor_set(x_296, 2, x_44);
+lean_ctor_set(x_296, 3, x_45);
+lean_ctor_set_uint8(x_296, sizeof(void*)*4, x_294);
+x_297 = 0;
+lean_ctor_set(x_1, 3, x_296);
+lean_ctor_set(x_1, 2, x_287);
+lean_ctor_set(x_1, 1, x_286);
+lean_ctor_set(x_1, 0, x_295);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_297);
+return x_1;
 }
 }
 else
 {
-lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; 
-x_293 = lean_ctor_get(x_186, 1);
-x_294 = lean_ctor_get(x_186, 2);
-lean_inc(x_294);
-lean_inc(x_293);
-lean_dec(x_186);
-x_295 = lean_ctor_get(x_260, 0);
-lean_inc(x_295);
-x_296 = lean_ctor_get(x_260, 1);
-lean_inc(x_296);
-x_297 = lean_ctor_get(x_260, 2);
-lean_inc(x_297);
-x_298 = lean_ctor_get(x_260, 3);
+lean_object* x_298; 
+x_298 = lean_ctor_get(x_216, 3);
 lean_inc(x_298);
-if (lean_is_exclusive(x_260)) {
- lean_ctor_release(x_260, 0);
- lean_ctor_release(x_260, 1);
- lean_ctor_release(x_260, 2);
- lean_ctor_release(x_260, 3);
- x_299 = x_260;
-} else {
- lean_dec_ref(x_260);
- x_299 = lean_box(0);
-}
-lean_inc(x_187);
-if (lean_is_scalar(x_299)) {
- x_300 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_300 = x_299;
-}
-lean_ctor_set(x_300, 0, x_187);
-lean_ctor_set(x_300, 1, x_293);
-lean_ctor_set(x_300, 2, x_294);
-lean_ctor_set(x_300, 3, x_295);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_301 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_301 = lean_box(0);
-}
-lean_ctor_set_uint8(x_300, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_301)) {
- x_302 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_302 = x_301;
-}
-lean_ctor_set(x_302, 0, x_298);
-lean_ctor_set(x_302, 1, x_36);
-lean_ctor_set(x_302, 2, x_37);
-lean_ctor_set(x_302, 3, x_38);
-lean_ctor_set_uint8(x_302, sizeof(void*)*4, x_235);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_300);
-lean_ctor_set(x_303, 1, x_296);
-lean_ctor_set(x_303, 2, x_297);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_269);
-return x_303;
-}
-}
-else
+if (lean_obj_tag(x_298) == 0)
 {
-uint8_t x_304; 
-x_304 = !lean_is_exclusive(x_186);
-if (x_304 == 0)
+uint8_t x_299; 
+x_299 = !lean_is_exclusive(x_216);
+if (x_299 == 0)
 {
-lean_object* x_305; lean_object* x_306; uint8_t x_307; 
-x_305 = lean_ctor_get(x_186, 3);
-lean_dec(x_305);
-x_306 = lean_ctor_get(x_186, 0);
-lean_dec(x_306);
-x_307 = !lean_is_exclusive(x_187);
-if (x_307 == 0)
-{
-uint8_t x_308; 
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_269);
-x_308 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_308);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_300; lean_object* x_301; uint8_t x_302; uint8_t x_303; 
+x_300 = lean_ctor_get(x_216, 3);
+lean_dec(x_300);
+x_301 = lean_ctor_get(x_216, 0);
+lean_dec(x_301);
+x_302 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_302);
+x_303 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_303);
 return x_1;
 }
 else
 {
-lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; uint8_t x_314; 
-x_309 = lean_ctor_get(x_187, 0);
-x_310 = lean_ctor_get(x_187, 1);
-x_311 = lean_ctor_get(x_187, 2);
-x_312 = lean_ctor_get(x_187, 3);
-lean_inc(x_312);
-lean_inc(x_311);
-lean_inc(x_310);
-lean_inc(x_309);
-lean_dec(x_187);
-x_313 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_313, 0, x_309);
-lean_ctor_set(x_313, 1, x_310);
-lean_ctor_set(x_313, 2, x_311);
-lean_ctor_set(x_313, 3, x_312);
-lean_ctor_set_uint8(x_313, sizeof(void*)*4, x_269);
-x_314 = 0;
-lean_ctor_set(x_186, 0, x_313);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_314);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_304; lean_object* x_305; uint8_t x_306; lean_object* x_307; uint8_t x_308; 
+x_304 = lean_ctor_get(x_216, 1);
+x_305 = lean_ctor_get(x_216, 2);
+lean_inc(x_305);
+lean_inc(x_304);
+lean_dec(x_216);
+x_306 = 0;
+x_307 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_307, 0, x_217);
+lean_ctor_set(x_307, 1, x_304);
+lean_ctor_set(x_307, 2, x_305);
+lean_ctor_set(x_307, 3, x_298);
+lean_ctor_set_uint8(x_307, sizeof(void*)*4, x_306);
+x_308 = 1;
+lean_ctor_set(x_1, 0, x_307);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_308);
 return x_1;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; 
-x_315 = lean_ctor_get(x_186, 1);
-x_316 = lean_ctor_get(x_186, 2);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_186);
-x_317 = lean_ctor_get(x_187, 0);
-lean_inc(x_317);
-x_318 = lean_ctor_get(x_187, 1);
-lean_inc(x_318);
-x_319 = lean_ctor_get(x_187, 2);
-lean_inc(x_319);
-x_320 = lean_ctor_get(x_187, 3);
-lean_inc(x_320);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_321 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_321 = lean_box(0);
-}
-if (lean_is_scalar(x_321)) {
- x_322 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_322 = x_321;
-}
-lean_ctor_set(x_322, 0, x_317);
-lean_ctor_set(x_322, 1, x_318);
-lean_ctor_set(x_322, 2, x_319);
-lean_ctor_set(x_322, 3, x_320);
-lean_ctor_set_uint8(x_322, sizeof(void*)*4, x_269);
-x_323 = 0;
-x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_322);
-lean_ctor_set(x_324, 1, x_315);
-lean_ctor_set(x_324, 2, x_316);
-lean_ctor_set(x_324, 3, x_260);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
-lean_ctor_set(x_1, 0, x_324);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_309; 
+x_309 = lean_ctor_get_uint8(x_298, sizeof(void*)*4);
+if (x_309 == 0)
+{
+uint8_t x_310; 
+lean_free_object(x_1);
+x_310 = !lean_is_exclusive(x_216);
+if (x_310 == 0)
+{
+lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; uint8_t x_315; 
+x_311 = lean_ctor_get(x_216, 1);
+x_312 = lean_ctor_get(x_216, 2);
+x_313 = lean_ctor_get(x_216, 3);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_216, 0);
+lean_dec(x_314);
+x_315 = !lean_is_exclusive(x_298);
+if (x_315 == 0)
+{
+lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; uint8_t x_320; uint8_t x_321; 
+x_316 = lean_ctor_get(x_298, 0);
+x_317 = lean_ctor_get(x_298, 1);
+x_318 = lean_ctor_get(x_298, 2);
+x_319 = lean_ctor_get(x_298, 3);
+x_320 = 1;
+lean_inc(x_217);
+lean_ctor_set(x_298, 3, x_316);
+lean_ctor_set(x_298, 2, x_312);
+lean_ctor_set(x_298, 1, x_311);
+lean_ctor_set(x_298, 0, x_217);
+x_321 = !lean_is_exclusive(x_217);
+if (x_321 == 0)
+{
+lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; uint8_t x_326; 
+x_322 = lean_ctor_get(x_217, 3);
+lean_dec(x_322);
+x_323 = lean_ctor_get(x_217, 2);
+lean_dec(x_323);
+x_324 = lean_ctor_get(x_217, 1);
+lean_dec(x_324);
+x_325 = lean_ctor_get(x_217, 0);
+lean_dec(x_325);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+lean_ctor_set(x_217, 3, x_45);
+lean_ctor_set(x_217, 2, x_44);
+lean_ctor_set(x_217, 1, x_43);
+lean_ctor_set(x_217, 0, x_319);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_320);
+x_326 = 0;
+lean_ctor_set(x_216, 3, x_217);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_326);
+return x_216;
 }
+else
+{
+lean_object* x_327; uint8_t x_328; 
+lean_dec(x_217);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+x_327 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_327, 0, x_319);
+lean_ctor_set(x_327, 1, x_43);
+lean_ctor_set(x_327, 2, x_44);
+lean_ctor_set(x_327, 3, x_45);
+lean_ctor_set_uint8(x_327, sizeof(void*)*4, x_320);
+x_328 = 0;
+lean_ctor_set(x_216, 3, x_327);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_328);
+return x_216;
 }
 }
 else
 {
-lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; uint32_t x_329; uint8_t x_330; 
-x_325 = lean_ctor_get(x_1, 0);
-x_326 = lean_ctor_get(x_1, 1);
-x_327 = lean_ctor_get(x_1, 2);
-x_328 = lean_ctor_get(x_1, 3);
-lean_inc(x_328);
-lean_inc(x_327);
-lean_inc(x_326);
-lean_inc(x_325);
-lean_dec(x_1);
-x_329 = lean_unbox_uint32(x_326);
-x_330 = x_2 < x_329;
-if (x_330 == 0)
-{
-uint32_t x_331; uint8_t x_332; 
-x_331 = lean_unbox_uint32(x_326);
-x_332 = x_331 < x_2;
-if (x_332 == 0)
-{
-lean_object* x_333; lean_object* x_334; 
-lean_dec(x_327);
-lean_dec(x_326);
-x_333 = lean_box_uint32(x_2);
+lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; uint8_t x_337; 
+x_329 = lean_ctor_get(x_298, 0);
+x_330 = lean_ctor_get(x_298, 1);
+x_331 = lean_ctor_get(x_298, 2);
+x_332 = lean_ctor_get(x_298, 3);
+lean_inc(x_332);
+lean_inc(x_331);
+lean_inc(x_330);
+lean_inc(x_329);
+lean_dec(x_298);
+x_333 = 1;
+lean_inc(x_217);
 x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_325);
-lean_ctor_set(x_334, 1, x_333);
-lean_ctor_set(x_334, 2, x_3);
-lean_ctor_set(x_334, 3, x_328);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_7);
-return x_334;
+lean_ctor_set(x_334, 0, x_217);
+lean_ctor_set(x_334, 1, x_311);
+lean_ctor_set(x_334, 2, x_312);
+lean_ctor_set(x_334, 3, x_329);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_335 = x_217;
+} else {
+ lean_dec_ref(x_217);
+ x_335 = lean_box(0);
+}
+lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
+if (lean_is_scalar(x_335)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_336 = x_335;
+}
+lean_ctor_set(x_336, 0, x_332);
+lean_ctor_set(x_336, 1, x_43);
+lean_ctor_set(x_336, 2, x_44);
+lean_ctor_set(x_336, 3, x_45);
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_333);
+x_337 = 0;
+lean_ctor_set(x_216, 3, x_336);
+lean_ctor_set(x_216, 2, x_331);
+lean_ctor_set(x_216, 1, x_330);
+lean_ctor_set(x_216, 0, x_334);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_337);
+return x_216;
+}
 }
 else
 {
-uint8_t x_335; 
-x_335 = l_Std_RBNode_isRed___rarg(x_328);
-if (x_335 == 0)
-{
-lean_object* x_336; lean_object* x_337; 
-x_336 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_328, x_2, x_3);
-x_337 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_337, 0, x_325);
-lean_ctor_set(x_337, 1, x_326);
-lean_ctor_set(x_337, 2, x_327);
-lean_ctor_set(x_337, 3, x_336);
-lean_ctor_set_uint8(x_337, sizeof(void*)*4, x_7);
-return x_337;
-}
-else
-{
-lean_object* x_338; lean_object* x_339; 
-x_338 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_328, x_2, x_3);
-x_339 = lean_ctor_get(x_338, 0);
+lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; uint8_t x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; uint8_t x_349; lean_object* x_350; 
+x_338 = lean_ctor_get(x_216, 1);
+x_339 = lean_ctor_get(x_216, 2);
 lean_inc(x_339);
-if (lean_obj_tag(x_339) == 0)
-{
-lean_object* x_340; 
-x_340 = lean_ctor_get(x_338, 3);
+lean_inc(x_338);
+lean_dec(x_216);
+x_340 = lean_ctor_get(x_298, 0);
 lean_inc(x_340);
-if (lean_obj_tag(x_340) == 0)
-{
-lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; uint8_t x_346; lean_object* x_347; 
-x_341 = lean_ctor_get(x_338, 1);
+x_341 = lean_ctor_get(x_298, 1);
 lean_inc(x_341);
-x_342 = lean_ctor_get(x_338, 2);
+x_342 = lean_ctor_get(x_298, 2);
 lean_inc(x_342);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_343 = x_338;
+x_343 = lean_ctor_get(x_298, 3);
+lean_inc(x_343);
+if (lean_is_exclusive(x_298)) {
+ lean_ctor_release(x_298, 0);
+ lean_ctor_release(x_298, 1);
+ lean_ctor_release(x_298, 2);
+ lean_ctor_release(x_298, 3);
+ x_344 = x_298;
 } else {
- lean_dec_ref(x_338);
- x_343 = lean_box(0);
+ lean_dec_ref(x_298);
+ x_344 = lean_box(0);
 }
-x_344 = 0;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
+x_345 = 1;
+lean_inc(x_217);
+if (lean_is_scalar(x_344)) {
+ x_346 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_345 = x_343;
+ x_346 = x_344;
 }
-lean_ctor_set(x_345, 0, x_340);
-lean_ctor_set(x_345, 1, x_341);
-lean_ctor_set(x_345, 2, x_342);
-lean_ctor_set(x_345, 3, x_340);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-x_346 = 1;
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_325);
-lean_ctor_set(x_347, 1, x_326);
-lean_ctor_set(x_347, 2, x_327);
-lean_ctor_set(x_347, 3, x_345);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_346);
-return x_347;
-}
-else
-{
-uint8_t x_348; 
-x_348 = lean_ctor_get_uint8(x_340, sizeof(void*)*4);
-if (x_348 == 0)
-{
-lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; uint8_t x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; 
-x_349 = lean_ctor_get(x_338, 1);
-lean_inc(x_349);
-x_350 = lean_ctor_get(x_338, 2);
-lean_inc(x_350);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_351 = x_338;
+lean_ctor_set(x_346, 0, x_217);
+lean_ctor_set(x_346, 1, x_338);
+lean_ctor_set(x_346, 2, x_339);
+lean_ctor_set(x_346, 3, x_340);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_347 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_351 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_347 = lean_box(0);
 }
-x_352 = lean_ctor_get(x_340, 0);
-lean_inc(x_352);
-x_353 = lean_ctor_get(x_340, 1);
-lean_inc(x_353);
-x_354 = lean_ctor_get(x_340, 2);
-lean_inc(x_354);
-x_355 = lean_ctor_get(x_340, 3);
-lean_inc(x_355);
-if (lean_is_exclusive(x_340)) {
- lean_ctor_release(x_340, 0);
- lean_ctor_release(x_340, 1);
- lean_ctor_release(x_340, 2);
- lean_ctor_release(x_340, 3);
- x_356 = x_340;
+lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_345);
+if (lean_is_scalar(x_347)) {
+ x_348 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_340);
- x_356 = lean_box(0);
-}
-x_357 = 1;
-if (lean_is_scalar(x_356)) {
- x_358 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_358 = x_356;
-}
-lean_ctor_set(x_358, 0, x_325);
-lean_ctor_set(x_358, 1, x_326);
-lean_ctor_set(x_358, 2, x_327);
-lean_ctor_set(x_358, 3, x_339);
-lean_ctor_set_uint8(x_358, sizeof(void*)*4, x_357);
-if (lean_is_scalar(x_351)) {
- x_359 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_359 = x_351;
-}
-lean_ctor_set(x_359, 0, x_352);
-lean_ctor_set(x_359, 1, x_353);
-lean_ctor_set(x_359, 2, x_354);
-lean_ctor_set(x_359, 3, x_355);
-lean_ctor_set_uint8(x_359, sizeof(void*)*4, x_357);
-x_360 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_360, 0, x_358);
-lean_ctor_set(x_360, 1, x_349);
-lean_ctor_set(x_360, 2, x_350);
-lean_ctor_set(x_360, 3, x_359);
-lean_ctor_set_uint8(x_360, sizeof(void*)*4, x_348);
-return x_360;
-}
-else
-{
-lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; 
-x_361 = lean_ctor_get(x_338, 1);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_338, 2);
-lean_inc(x_362);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_363 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_363 = lean_box(0);
-}
-x_364 = 0;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
-}
-lean_ctor_set(x_365, 0, x_339);
-lean_ctor_set(x_365, 1, x_361);
-lean_ctor_set(x_365, 2, x_362);
-lean_ctor_set(x_365, 3, x_340);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-x_366 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_366, 0, x_325);
-lean_ctor_set(x_366, 1, x_326);
-lean_ctor_set(x_366, 2, x_327);
-lean_ctor_set(x_366, 3, x_365);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_348);
-return x_366;
+ x_348 = x_347;
 }
+lean_ctor_set(x_348, 0, x_343);
+lean_ctor_set(x_348, 1, x_43);
+lean_ctor_set(x_348, 2, x_44);
+lean_ctor_set(x_348, 3, x_45);
+lean_ctor_set_uint8(x_348, sizeof(void*)*4, x_345);
+x_349 = 0;
+x_350 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_350, 0, x_346);
+lean_ctor_set(x_350, 1, x_341);
+lean_ctor_set(x_350, 2, x_342);
+lean_ctor_set(x_350, 3, x_348);
+lean_ctor_set_uint8(x_350, sizeof(void*)*4, x_349);
+return x_350;
 }
 }
 else
 {
-uint8_t x_367; 
-x_367 = lean_ctor_get_uint8(x_339, sizeof(void*)*4);
-if (x_367 == 0)
+uint8_t x_351; 
+x_351 = !lean_is_exclusive(x_216);
+if (x_351 == 0)
 {
-lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; uint8_t x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; 
-x_368 = lean_ctor_get(x_338, 1);
+lean_object* x_352; lean_object* x_353; uint8_t x_354; 
+x_352 = lean_ctor_get(x_216, 3);
+lean_dec(x_352);
+x_353 = lean_ctor_get(x_216, 0);
+lean_dec(x_353);
+x_354 = !lean_is_exclusive(x_217);
+if (x_354 == 0)
+{
+uint8_t x_355; uint8_t x_356; 
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_309);
+x_355 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_355);
+x_356 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_356);
+return x_1;
+}
+else
+{
+lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; uint8_t x_363; 
+x_357 = lean_ctor_get(x_217, 0);
+x_358 = lean_ctor_get(x_217, 1);
+x_359 = lean_ctor_get(x_217, 2);
+x_360 = lean_ctor_get(x_217, 3);
+lean_inc(x_360);
+lean_inc(x_359);
+lean_inc(x_358);
+lean_inc(x_357);
+lean_dec(x_217);
+x_361 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_361, 0, x_357);
+lean_ctor_set(x_361, 1, x_358);
+lean_ctor_set(x_361, 2, x_359);
+lean_ctor_set(x_361, 3, x_360);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_309);
+x_362 = 0;
+lean_ctor_set(x_216, 0, x_361);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_362);
+x_363 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_363);
+return x_1;
+}
+}
+else
+{
+lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; uint8_t x_374; 
+x_364 = lean_ctor_get(x_216, 1);
+x_365 = lean_ctor_get(x_216, 2);
+lean_inc(x_365);
+lean_inc(x_364);
+lean_dec(x_216);
+x_366 = lean_ctor_get(x_217, 0);
+lean_inc(x_366);
+x_367 = lean_ctor_get(x_217, 1);
+lean_inc(x_367);
+x_368 = lean_ctor_get(x_217, 2);
 lean_inc(x_368);
-x_369 = lean_ctor_get(x_338, 2);
+x_369 = lean_ctor_get(x_217, 3);
 lean_inc(x_369);
-x_370 = lean_ctor_get(x_338, 3);
-lean_inc(x_370);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_371 = x_338;
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_370 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_371 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_370 = lean_box(0);
 }
-x_372 = lean_ctor_get(x_339, 0);
-lean_inc(x_372);
-x_373 = lean_ctor_get(x_339, 1);
-lean_inc(x_373);
-x_374 = lean_ctor_get(x_339, 2);
-lean_inc(x_374);
-x_375 = lean_ctor_get(x_339, 3);
+if (lean_is_scalar(x_370)) {
+ x_371 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_371 = x_370;
+}
+lean_ctor_set(x_371, 0, x_366);
+lean_ctor_set(x_371, 1, x_367);
+lean_ctor_set(x_371, 2, x_368);
+lean_ctor_set(x_371, 3, x_369);
+lean_ctor_set_uint8(x_371, sizeof(void*)*4, x_309);
+x_372 = 0;
+x_373 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_373, 0, x_371);
+lean_ctor_set(x_373, 1, x_364);
+lean_ctor_set(x_373, 2, x_365);
+lean_ctor_set(x_373, 3, x_298);
+lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
+x_374 = 1;
+lean_ctor_set(x_1, 0, x_373);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_374);
+return x_1;
+}
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; uint32_t x_379; uint8_t x_380; 
+x_375 = lean_ctor_get(x_1, 0);
+x_376 = lean_ctor_get(x_1, 1);
+x_377 = lean_ctor_get(x_1, 2);
+x_378 = lean_ctor_get(x_1, 3);
+lean_inc(x_378);
+lean_inc(x_377);
+lean_inc(x_376);
 lean_inc(x_375);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_376 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_376 = lean_box(0);
-}
-x_377 = 1;
-if (lean_is_scalar(x_376)) {
- x_378 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_378 = x_376;
-}
-lean_ctor_set(x_378, 0, x_325);
-lean_ctor_set(x_378, 1, x_326);
-lean_ctor_set(x_378, 2, x_327);
-lean_ctor_set(x_378, 3, x_372);
-lean_ctor_set_uint8(x_378, sizeof(void*)*4, x_377);
-if (lean_is_scalar(x_371)) {
- x_379 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_379 = x_371;
-}
-lean_ctor_set(x_379, 0, x_375);
-lean_ctor_set(x_379, 1, x_368);
-lean_ctor_set(x_379, 2, x_369);
-lean_ctor_set(x_379, 3, x_370);
-lean_ctor_set_uint8(x_379, sizeof(void*)*4, x_377);
-x_380 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_380, 0, x_378);
-lean_ctor_set(x_380, 1, x_373);
-lean_ctor_set(x_380, 2, x_374);
-lean_ctor_set(x_380, 3, x_379);
-lean_ctor_set_uint8(x_380, sizeof(void*)*4, x_367);
-return x_380;
+lean_dec(x_1);
+x_379 = lean_unbox_uint32(x_376);
+x_380 = x_2 < x_379;
+if (x_380 == 0)
+{
+uint32_t x_381; uint8_t x_382; 
+x_381 = lean_unbox_uint32(x_376);
+x_382 = x_381 < x_2;
+if (x_382 == 0)
+{
+uint8_t x_383; lean_object* x_384; lean_object* x_385; 
+lean_dec(x_377);
+lean_dec(x_376);
+x_383 = 1;
+x_384 = lean_box_uint32(x_2);
+x_385 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_385, 0, x_375);
+lean_ctor_set(x_385, 1, x_384);
+lean_ctor_set(x_385, 2, x_3);
+lean_ctor_set(x_385, 3, x_378);
+lean_ctor_set_uint8(x_385, sizeof(void*)*4, x_383);
+return x_385;
 }
 else
 {
-lean_object* x_381; 
-x_381 = lean_ctor_get(x_338, 3);
-lean_inc(x_381);
-if (lean_obj_tag(x_381) == 0)
+uint8_t x_386; 
+x_386 = l_Std_RBNode_isRed___rarg(x_378);
+if (x_386 == 0)
 {
-lean_object* x_382; lean_object* x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; lean_object* x_387; 
-x_382 = lean_ctor_get(x_338, 1);
-lean_inc(x_382);
-x_383 = lean_ctor_get(x_338, 2);
-lean_inc(x_383);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_384 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_384 = lean_box(0);
-}
-x_385 = 0;
-if (lean_is_scalar(x_384)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_384;
-}
-lean_ctor_set(x_386, 0, x_339);
-lean_ctor_set(x_386, 1, x_382);
-lean_ctor_set(x_386, 2, x_383);
-lean_ctor_set(x_386, 3, x_381);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
-x_387 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_387, 0, x_325);
-lean_ctor_set(x_387, 1, x_326);
-lean_ctor_set(x_387, 2, x_327);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_367);
-return x_387;
+lean_object* x_387; uint8_t x_388; lean_object* x_389; 
+x_387 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_378, x_2, x_3);
+x_388 = 1;
+x_389 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_389, 0, x_375);
+lean_ctor_set(x_389, 1, x_376);
+lean_ctor_set(x_389, 2, x_377);
+lean_ctor_set(x_389, 3, x_387);
+lean_ctor_set_uint8(x_389, sizeof(void*)*4, x_388);
+return x_389;
 }
 else
 {
-uint8_t x_388; 
-x_388 = lean_ctor_get_uint8(x_381, sizeof(void*)*4);
-if (x_388 == 0)
+lean_object* x_390; lean_object* x_391; 
+x_390 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_378, x_2, x_3);
+x_391 = lean_ctor_get(x_390, 0);
+lean_inc(x_391);
+if (lean_obj_tag(x_391) == 0)
 {
-lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; 
-x_389 = lean_ctor_get(x_338, 1);
-lean_inc(x_389);
-x_390 = lean_ctor_get(x_338, 2);
-lean_inc(x_390);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_391 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_391 = lean_box(0);
-}
-x_392 = lean_ctor_get(x_381, 0);
+lean_object* x_392; 
+x_392 = lean_ctor_get(x_390, 3);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_381, 1);
+if (lean_obj_tag(x_392) == 0)
+{
+lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; uint8_t x_398; lean_object* x_399; 
+x_393 = lean_ctor_get(x_390, 1);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_381, 2);
+x_394 = lean_ctor_get(x_390, 2);
 lean_inc(x_394);
-x_395 = lean_ctor_get(x_381, 3);
-lean_inc(x_395);
-if (lean_is_exclusive(x_381)) {
- lean_ctor_release(x_381, 0);
- lean_ctor_release(x_381, 1);
- lean_ctor_release(x_381, 2);
- lean_ctor_release(x_381, 3);
- x_396 = x_381;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_395 = x_390;
 } else {
- lean_dec_ref(x_381);
- x_396 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_395 = lean_box(0);
 }
-lean_inc(x_339);
-if (lean_is_scalar(x_396)) {
+x_396 = 0;
+if (lean_is_scalar(x_395)) {
  x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_397 = x_396;
+ x_397 = x_395;
 }
-lean_ctor_set(x_397, 0, x_325);
-lean_ctor_set(x_397, 1, x_326);
-lean_ctor_set(x_397, 2, x_327);
-lean_ctor_set(x_397, 3, x_339);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_398 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_398 = lean_box(0);
-}
-lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_398)) {
- x_399 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_399 = x_398;
-}
-lean_ctor_set(x_399, 0, x_392);
-lean_ctor_set(x_399, 1, x_393);
-lean_ctor_set(x_399, 2, x_394);
-lean_ctor_set(x_399, 3, x_395);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_391)) {
- x_400 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_400 = x_391;
-}
-lean_ctor_set(x_400, 0, x_397);
-lean_ctor_set(x_400, 1, x_389);
-lean_ctor_set(x_400, 2, x_390);
-lean_ctor_set(x_400, 3, x_399);
-lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_388);
-return x_400;
+lean_ctor_set(x_397, 0, x_392);
+lean_ctor_set(x_397, 1, x_393);
+lean_ctor_set(x_397, 2, x_394);
+lean_ctor_set(x_397, 3, x_392);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
+x_398 = 1;
+x_399 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_399, 0, x_375);
+lean_ctor_set(x_399, 1, x_376);
+lean_ctor_set(x_399, 2, x_377);
+lean_ctor_set(x_399, 3, x_397);
+lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_398);
+return x_399;
 }
 else
 {
-lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; uint8_t x_410; lean_object* x_411; lean_object* x_412; 
-x_401 = lean_ctor_get(x_338, 1);
+uint8_t x_400; 
+x_400 = lean_ctor_get_uint8(x_392, sizeof(void*)*4);
+if (x_400 == 0)
+{
+lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; lean_object* x_411; uint8_t x_412; lean_object* x_413; 
+x_401 = lean_ctor_get(x_390, 1);
 lean_inc(x_401);
-x_402 = lean_ctor_get(x_338, 2);
+x_402 = lean_ctor_get(x_390, 2);
 lean_inc(x_402);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_403 = x_338;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_403 = x_390;
 } else {
- lean_dec_ref(x_338);
+ lean_dec_ref(x_390);
  x_403 = lean_box(0);
 }
-x_404 = lean_ctor_get(x_339, 0);
+x_404 = lean_ctor_get(x_392, 0);
 lean_inc(x_404);
-x_405 = lean_ctor_get(x_339, 1);
+x_405 = lean_ctor_get(x_392, 1);
 lean_inc(x_405);
-x_406 = lean_ctor_get(x_339, 2);
+x_406 = lean_ctor_get(x_392, 2);
 lean_inc(x_406);
-x_407 = lean_ctor_get(x_339, 3);
+x_407 = lean_ctor_get(x_392, 3);
 lean_inc(x_407);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_408 = x_339;
+if (lean_is_exclusive(x_392)) {
+ lean_ctor_release(x_392, 0);
+ lean_ctor_release(x_392, 1);
+ lean_ctor_release(x_392, 2);
+ lean_ctor_release(x_392, 3);
+ x_408 = x_392;
 } else {
- lean_dec_ref(x_339);
+ lean_dec_ref(x_392);
  x_408 = lean_box(0);
 }
+x_409 = 1;
 if (lean_is_scalar(x_408)) {
- x_409 = lean_alloc_ctor(1, 4, 1);
+ x_410 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_409 = x_408;
+ x_410 = x_408;
 }
-lean_ctor_set(x_409, 0, x_404);
-lean_ctor_set(x_409, 1, x_405);
-lean_ctor_set(x_409, 2, x_406);
-lean_ctor_set(x_409, 3, x_407);
-lean_ctor_set_uint8(x_409, sizeof(void*)*4, x_388);
-x_410 = 0;
+lean_ctor_set(x_410, 0, x_375);
+lean_ctor_set(x_410, 1, x_376);
+lean_ctor_set(x_410, 2, x_377);
+lean_ctor_set(x_410, 3, x_391);
+lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
 if (lean_is_scalar(x_403)) {
  x_411 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_411 = x_403;
 }
-lean_ctor_set(x_411, 0, x_409);
-lean_ctor_set(x_411, 1, x_401);
-lean_ctor_set(x_411, 2, x_402);
-lean_ctor_set(x_411, 3, x_381);
-lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_410);
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_325);
-lean_ctor_set(x_412, 1, x_326);
-lean_ctor_set(x_412, 2, x_327);
-lean_ctor_set(x_412, 3, x_411);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_388);
-return x_412;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_411, 0, x_404);
+lean_ctor_set(x_411, 1, x_405);
+lean_ctor_set(x_411, 2, x_406);
+lean_ctor_set(x_411, 3, x_407);
+lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_409);
+x_412 = 0;
+x_413 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_413, 0, x_410);
+lean_ctor_set(x_413, 1, x_401);
+lean_ctor_set(x_413, 2, x_402);
+lean_ctor_set(x_413, 3, x_411);
+lean_ctor_set_uint8(x_413, sizeof(void*)*4, x_412);
+return x_413;
 }
 else
 {
-uint8_t x_413; 
-x_413 = l_Std_RBNode_isRed___rarg(x_325);
-if (x_413 == 0)
-{
-lean_object* x_414; lean_object* x_415; 
-x_414 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_325, x_2, x_3);
-x_415 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_415, 0, x_414);
-lean_ctor_set(x_415, 1, x_326);
-lean_ctor_set(x_415, 2, x_327);
-lean_ctor_set(x_415, 3, x_328);
-lean_ctor_set_uint8(x_415, sizeof(void*)*4, x_7);
-return x_415;
-}
-else
-{
-lean_object* x_416; lean_object* x_417; 
-x_416 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_325, x_2, x_3);
-x_417 = lean_ctor_get(x_416, 0);
-lean_inc(x_417);
-if (lean_obj_tag(x_417) == 0)
-{
-lean_object* x_418; 
-x_418 = lean_ctor_get(x_416, 3);
-lean_inc(x_418);
-if (lean_obj_tag(x_418) == 0)
-{
-lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; uint8_t x_424; lean_object* x_425; 
-x_419 = lean_ctor_get(x_416, 1);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_416, 2);
-lean_inc(x_420);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_421 = x_416;
+lean_object* x_414; lean_object* x_415; lean_object* x_416; uint8_t x_417; lean_object* x_418; uint8_t x_419; lean_object* x_420; 
+x_414 = lean_ctor_get(x_390, 1);
+lean_inc(x_414);
+x_415 = lean_ctor_get(x_390, 2);
+lean_inc(x_415);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_416 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_421 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_416 = lean_box(0);
 }
-x_422 = 0;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+x_417 = 0;
+if (lean_is_scalar(x_416)) {
+ x_418 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_418 = x_416;
+}
+lean_ctor_set(x_418, 0, x_391);
+lean_ctor_set(x_418, 1, x_414);
+lean_ctor_set(x_418, 2, x_415);
+lean_ctor_set(x_418, 3, x_392);
+lean_ctor_set_uint8(x_418, sizeof(void*)*4, x_417);
+x_419 = 1;
+x_420 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_420, 0, x_375);
+lean_ctor_set(x_420, 1, x_376);
+lean_ctor_set(x_420, 2, x_377);
+lean_ctor_set(x_420, 3, x_418);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_419);
+return x_420;
+}
 }
-lean_ctor_set(x_423, 0, x_418);
-lean_ctor_set(x_423, 1, x_419);
-lean_ctor_set(x_423, 2, x_420);
-lean_ctor_set(x_423, 3, x_418);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-x_424 = 1;
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_326);
-lean_ctor_set(x_425, 2, x_327);
-lean_ctor_set(x_425, 3, x_328);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_424);
-return x_425;
 }
 else
 {
-uint8_t x_426; 
-x_426 = lean_ctor_get_uint8(x_418, sizeof(void*)*4);
-if (x_426 == 0)
+uint8_t x_421; 
+x_421 = lean_ctor_get_uint8(x_391, sizeof(void*)*4);
+if (x_421 == 0)
 {
-lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; uint8_t x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; 
-x_427 = lean_ctor_get(x_416, 1);
+lean_object* x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; uint8_t x_431; lean_object* x_432; lean_object* x_433; uint8_t x_434; lean_object* x_435; 
+x_422 = lean_ctor_get(x_390, 1);
+lean_inc(x_422);
+x_423 = lean_ctor_get(x_390, 2);
+lean_inc(x_423);
+x_424 = lean_ctor_get(x_390, 3);
+lean_inc(x_424);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_425 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_425 = lean_box(0);
+}
+x_426 = lean_ctor_get(x_391, 0);
+lean_inc(x_426);
+x_427 = lean_ctor_get(x_391, 1);
 lean_inc(x_427);
-x_428 = lean_ctor_get(x_416, 2);
+x_428 = lean_ctor_get(x_391, 2);
 lean_inc(x_428);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_429 = x_416;
+x_429 = lean_ctor_get(x_391, 3);
+lean_inc(x_429);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_430 = x_391;
 } else {
- lean_dec_ref(x_416);
- x_429 = lean_box(0);
+ lean_dec_ref(x_391);
+ x_430 = lean_box(0);
 }
-x_430 = lean_ctor_get(x_418, 0);
-lean_inc(x_430);
-x_431 = lean_ctor_get(x_418, 1);
-lean_inc(x_431);
-x_432 = lean_ctor_get(x_418, 2);
-lean_inc(x_432);
-x_433 = lean_ctor_get(x_418, 3);
-lean_inc(x_433);
-if (lean_is_exclusive(x_418)) {
- lean_ctor_release(x_418, 0);
- lean_ctor_release(x_418, 1);
- lean_ctor_release(x_418, 2);
- lean_ctor_release(x_418, 3);
- x_434 = x_418;
+x_431 = 1;
+if (lean_is_scalar(x_430)) {
+ x_432 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_418);
- x_434 = lean_box(0);
+ x_432 = x_430;
 }
-x_435 = 1;
-if (lean_is_scalar(x_434)) {
- x_436 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_432, 0, x_375);
+lean_ctor_set(x_432, 1, x_376);
+lean_ctor_set(x_432, 2, x_377);
+lean_ctor_set(x_432, 3, x_426);
+lean_ctor_set_uint8(x_432, sizeof(void*)*4, x_431);
+if (lean_is_scalar(x_425)) {
+ x_433 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_436 = x_434;
+ x_433 = x_425;
 }
-lean_ctor_set(x_436, 0, x_417);
-lean_ctor_set(x_436, 1, x_427);
-lean_ctor_set(x_436, 2, x_428);
-lean_ctor_set(x_436, 3, x_430);
-lean_ctor_set_uint8(x_436, sizeof(void*)*4, x_435);
-if (lean_is_scalar(x_429)) {
- x_437 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_437 = x_429;
-}
-lean_ctor_set(x_437, 0, x_433);
-lean_ctor_set(x_437, 1, x_326);
-lean_ctor_set(x_437, 2, x_327);
-lean_ctor_set(x_437, 3, x_328);
-lean_ctor_set_uint8(x_437, sizeof(void*)*4, x_435);
-x_438 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_438, 0, x_436);
-lean_ctor_set(x_438, 1, x_431);
-lean_ctor_set(x_438, 2, x_432);
-lean_ctor_set(x_438, 3, x_437);
-lean_ctor_set_uint8(x_438, sizeof(void*)*4, x_426);
-return x_438;
+lean_ctor_set(x_433, 0, x_429);
+lean_ctor_set(x_433, 1, x_422);
+lean_ctor_set(x_433, 2, x_423);
+lean_ctor_set(x_433, 3, x_424);
+lean_ctor_set_uint8(x_433, sizeof(void*)*4, x_431);
+x_434 = 0;
+x_435 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_435, 0, x_432);
+lean_ctor_set(x_435, 1, x_427);
+lean_ctor_set(x_435, 2, x_428);
+lean_ctor_set(x_435, 3, x_433);
+lean_ctor_set_uint8(x_435, sizeof(void*)*4, x_434);
+return x_435;
 }
 else
 {
-lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; 
-x_439 = lean_ctor_get(x_416, 1);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_416, 2);
-lean_inc(x_440);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_441 = x_416;
+lean_object* x_436; 
+x_436 = lean_ctor_get(x_390, 3);
+lean_inc(x_436);
+if (lean_obj_tag(x_436) == 0)
+{
+lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; 
+x_437 = lean_ctor_get(x_390, 1);
+lean_inc(x_437);
+x_438 = lean_ctor_get(x_390, 2);
+lean_inc(x_438);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_439 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_441 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_439 = lean_box(0);
 }
-x_442 = 0;
-if (lean_is_scalar(x_441)) {
- x_443 = lean_alloc_ctor(1, 4, 1);
+x_440 = 0;
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_441 = x_439;
 }
-lean_ctor_set(x_443, 0, x_417);
-lean_ctor_set(x_443, 1, x_439);
-lean_ctor_set(x_443, 2, x_440);
-lean_ctor_set(x_443, 3, x_418);
+lean_ctor_set(x_441, 0, x_391);
+lean_ctor_set(x_441, 1, x_437);
+lean_ctor_set(x_441, 2, x_438);
+lean_ctor_set(x_441, 3, x_436);
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+x_442 = 1;
+x_443 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_375);
+lean_ctor_set(x_443, 1, x_376);
+lean_ctor_set(x_443, 2, x_377);
+lean_ctor_set(x_443, 3, x_441);
 lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-x_444 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_444, 0, x_443);
-lean_ctor_set(x_444, 1, x_326);
-lean_ctor_set(x_444, 2, x_327);
-lean_ctor_set(x_444, 3, x_328);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_426);
-return x_444;
-}
-}
+return x_443;
 }
 else
 {
-uint8_t x_445; 
-x_445 = lean_ctor_get_uint8(x_417, sizeof(void*)*4);
-if (x_445 == 0)
+uint8_t x_444; 
+x_444 = lean_ctor_get_uint8(x_436, sizeof(void*)*4);
+if (x_444 == 0)
 {
-lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; 
-x_446 = lean_ctor_get(x_416, 1);
+lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; uint8_t x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_445 = lean_ctor_get(x_390, 1);
+lean_inc(x_445);
+x_446 = lean_ctor_get(x_390, 2);
 lean_inc(x_446);
-x_447 = lean_ctor_get(x_416, 2);
-lean_inc(x_447);
-x_448 = lean_ctor_get(x_416, 3);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_447 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_447 = lean_box(0);
+}
+x_448 = lean_ctor_get(x_436, 0);
 lean_inc(x_448);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_449 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_449 = lean_box(0);
-}
-x_450 = lean_ctor_get(x_417, 0);
+x_449 = lean_ctor_get(x_436, 1);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_436, 2);
 lean_inc(x_450);
-x_451 = lean_ctor_get(x_417, 1);
+x_451 = lean_ctor_get(x_436, 3);
 lean_inc(x_451);
-x_452 = lean_ctor_get(x_417, 2);
-lean_inc(x_452);
-x_453 = lean_ctor_get(x_417, 3);
-lean_inc(x_453);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_454 = x_417;
+if (lean_is_exclusive(x_436)) {
+ lean_ctor_release(x_436, 0);
+ lean_ctor_release(x_436, 1);
+ lean_ctor_release(x_436, 2);
+ lean_ctor_release(x_436, 3);
+ x_452 = x_436;
 } else {
- lean_dec_ref(x_417);
- x_454 = lean_box(0);
+ lean_dec_ref(x_436);
+ x_452 = lean_box(0);
 }
-x_455 = 1;
-if (lean_is_scalar(x_454)) {
+x_453 = 1;
+lean_inc(x_391);
+if (lean_is_scalar(x_452)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_452;
+}
+lean_ctor_set(x_454, 0, x_375);
+lean_ctor_set(x_454, 1, x_376);
+lean_ctor_set(x_454, 2, x_377);
+lean_ctor_set(x_454, 3, x_391);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_455 = x_391;
+} else {
+ lean_dec_ref(x_391);
+ x_455 = lean_box(0);
+}
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_453);
+if (lean_is_scalar(x_455)) {
  x_456 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_456 = x_454;
+ x_456 = x_455;
 }
-lean_ctor_set(x_456, 0, x_450);
-lean_ctor_set(x_456, 1, x_451);
-lean_ctor_set(x_456, 2, x_452);
-lean_ctor_set(x_456, 3, x_453);
-lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
-if (lean_is_scalar(x_449)) {
- x_457 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_456, 0, x_448);
+lean_ctor_set(x_456, 1, x_449);
+lean_ctor_set(x_456, 2, x_450);
+lean_ctor_set(x_456, 3, x_451);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_453);
+x_457 = 0;
+if (lean_is_scalar(x_447)) {
+ x_458 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_457 = x_449;
+ x_458 = x_447;
 }
-lean_ctor_set(x_457, 0, x_448);
-lean_ctor_set(x_457, 1, x_326);
-lean_ctor_set(x_457, 2, x_327);
-lean_ctor_set(x_457, 3, x_328);
-lean_ctor_set_uint8(x_457, sizeof(void*)*4, x_455);
-x_458 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_458, 0, x_456);
-lean_ctor_set(x_458, 1, x_446);
-lean_ctor_set(x_458, 2, x_447);
-lean_ctor_set(x_458, 3, x_457);
-lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_445);
+lean_ctor_set(x_458, 0, x_454);
+lean_ctor_set(x_458, 1, x_445);
+lean_ctor_set(x_458, 2, x_446);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
 return x_458;
 }
 else
 {
-lean_object* x_459; 
-x_459 = lean_ctor_get(x_416, 3);
+lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; uint8_t x_468; lean_object* x_469; uint8_t x_470; lean_object* x_471; 
+x_459 = lean_ctor_get(x_390, 1);
 lean_inc(x_459);
-if (lean_obj_tag(x_459) == 0)
-{
-lean_object* x_460; lean_object* x_461; lean_object* x_462; uint8_t x_463; lean_object* x_464; lean_object* x_465; 
-x_460 = lean_ctor_get(x_416, 1);
+x_460 = lean_ctor_get(x_390, 2);
 lean_inc(x_460);
-x_461 = lean_ctor_get(x_416, 2);
-lean_inc(x_461);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_462 = x_416;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_461 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_462 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_461 = lean_box(0);
 }
-x_463 = 0;
-if (lean_is_scalar(x_462)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
+x_462 = lean_ctor_get(x_391, 0);
+lean_inc(x_462);
+x_463 = lean_ctor_get(x_391, 1);
+lean_inc(x_463);
+x_464 = lean_ctor_get(x_391, 2);
+lean_inc(x_464);
+x_465 = lean_ctor_get(x_391, 3);
+lean_inc(x_465);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_466 = x_391;
 } else {
- x_464 = x_462;
+ lean_dec_ref(x_391);
+ x_466 = lean_box(0);
+}
+if (lean_is_scalar(x_466)) {
+ x_467 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_467 = x_466;
+}
+lean_ctor_set(x_467, 0, x_462);
+lean_ctor_set(x_467, 1, x_463);
+lean_ctor_set(x_467, 2, x_464);
+lean_ctor_set(x_467, 3, x_465);
+lean_ctor_set_uint8(x_467, sizeof(void*)*4, x_444);
+x_468 = 0;
+if (lean_is_scalar(x_461)) {
+ x_469 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_469 = x_461;
+}
+lean_ctor_set(x_469, 0, x_467);
+lean_ctor_set(x_469, 1, x_459);
+lean_ctor_set(x_469, 2, x_460);
+lean_ctor_set(x_469, 3, x_436);
+lean_ctor_set_uint8(x_469, sizeof(void*)*4, x_468);
+x_470 = 1;
+x_471 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_471, 0, x_375);
+lean_ctor_set(x_471, 1, x_376);
+lean_ctor_set(x_471, 2, x_377);
+lean_ctor_set(x_471, 3, x_469);
+lean_ctor_set_uint8(x_471, sizeof(void*)*4, x_470);
+return x_471;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_464, 0, x_417);
-lean_ctor_set(x_464, 1, x_460);
-lean_ctor_set(x_464, 2, x_461);
-lean_ctor_set(x_464, 3, x_459);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_463);
-x_465 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_465, 0, x_464);
-lean_ctor_set(x_465, 1, x_326);
-lean_ctor_set(x_465, 2, x_327);
-lean_ctor_set(x_465, 3, x_328);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_445);
-return x_465;
 }
 else
 {
-uint8_t x_466; 
-x_466 = lean_ctor_get_uint8(x_459, sizeof(void*)*4);
-if (x_466 == 0)
+uint8_t x_472; 
+x_472 = l_Std_RBNode_isRed___rarg(x_375);
+if (x_472 == 0)
 {
-lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; 
-x_467 = lean_ctor_get(x_416, 1);
-lean_inc(x_467);
-x_468 = lean_ctor_get(x_416, 2);
-lean_inc(x_468);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_469 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_469 = lean_box(0);
-}
-x_470 = lean_ctor_get(x_459, 0);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_459, 1);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_459, 2);
-lean_inc(x_472);
-x_473 = lean_ctor_get(x_459, 3);
-lean_inc(x_473);
-if (lean_is_exclusive(x_459)) {
- lean_ctor_release(x_459, 0);
- lean_ctor_release(x_459, 1);
- lean_ctor_release(x_459, 2);
- lean_ctor_release(x_459, 3);
- x_474 = x_459;
-} else {
- lean_dec_ref(x_459);
- x_474 = lean_box(0);
-}
-lean_inc(x_417);
-if (lean_is_scalar(x_474)) {
- x_475 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_475 = x_474;
-}
-lean_ctor_set(x_475, 0, x_417);
-lean_ctor_set(x_475, 1, x_467);
-lean_ctor_set(x_475, 2, x_468);
-lean_ctor_set(x_475, 3, x_470);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_476 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_476 = lean_box(0);
-}
-lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_476)) {
- x_477 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_477 = x_476;
-}
-lean_ctor_set(x_477, 0, x_473);
-lean_ctor_set(x_477, 1, x_326);
-lean_ctor_set(x_477, 2, x_327);
-lean_ctor_set(x_477, 3, x_328);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_469)) {
- x_478 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_478 = x_469;
-}
-lean_ctor_set(x_478, 0, x_475);
-lean_ctor_set(x_478, 1, x_471);
-lean_ctor_set(x_478, 2, x_472);
-lean_ctor_set(x_478, 3, x_477);
-lean_ctor_set_uint8(x_478, sizeof(void*)*4, x_466);
-return x_478;
+lean_object* x_473; uint8_t x_474; lean_object* x_475; 
+x_473 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_375, x_2, x_3);
+x_474 = 1;
+x_475 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_475, 0, x_473);
+lean_ctor_set(x_475, 1, x_376);
+lean_ctor_set(x_475, 2, x_377);
+lean_ctor_set(x_475, 3, x_378);
+lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_474);
+return x_475;
 }
 else
 {
-lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; uint8_t x_488; lean_object* x_489; lean_object* x_490; 
-x_479 = lean_ctor_get(x_416, 1);
+lean_object* x_476; lean_object* x_477; 
+x_476 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_375, x_2, x_3);
+x_477 = lean_ctor_get(x_476, 0);
+lean_inc(x_477);
+if (lean_obj_tag(x_477) == 0)
+{
+lean_object* x_478; 
+x_478 = lean_ctor_get(x_476, 3);
+lean_inc(x_478);
+if (lean_obj_tag(x_478) == 0)
+{
+lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; uint8_t x_484; lean_object* x_485; 
+x_479 = lean_ctor_get(x_476, 1);
 lean_inc(x_479);
-x_480 = lean_ctor_get(x_416, 2);
+x_480 = lean_ctor_get(x_476, 2);
 lean_inc(x_480);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_481 = x_416;
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_481 = x_476;
 } else {
- lean_dec_ref(x_416);
+ lean_dec_ref(x_476);
  x_481 = lean_box(0);
 }
-x_482 = lean_ctor_get(x_417, 0);
-lean_inc(x_482);
-x_483 = lean_ctor_get(x_417, 1);
-lean_inc(x_483);
-x_484 = lean_ctor_get(x_417, 2);
-lean_inc(x_484);
-x_485 = lean_ctor_get(x_417, 3);
-lean_inc(x_485);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_486 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_486 = lean_box(0);
-}
-if (lean_is_scalar(x_486)) {
- x_487 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_487 = x_486;
-}
-lean_ctor_set(x_487, 0, x_482);
-lean_ctor_set(x_487, 1, x_483);
-lean_ctor_set(x_487, 2, x_484);
-lean_ctor_set(x_487, 3, x_485);
-lean_ctor_set_uint8(x_487, sizeof(void*)*4, x_466);
-x_488 = 0;
+x_482 = 0;
 if (lean_is_scalar(x_481)) {
- x_489 = lean_alloc_ctor(1, 4, 1);
+ x_483 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_489 = x_481;
+ x_483 = x_481;
 }
-lean_ctor_set(x_489, 0, x_487);
-lean_ctor_set(x_489, 1, x_479);
-lean_ctor_set(x_489, 2, x_480);
-lean_ctor_set(x_489, 3, x_459);
-lean_ctor_set_uint8(x_489, sizeof(void*)*4, x_488);
-x_490 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_490, 0, x_489);
-lean_ctor_set(x_490, 1, x_326);
-lean_ctor_set(x_490, 2, x_327);
-lean_ctor_set(x_490, 3, x_328);
-lean_ctor_set_uint8(x_490, sizeof(void*)*4, x_466);
-return x_490;
+lean_ctor_set(x_483, 0, x_478);
+lean_ctor_set(x_483, 1, x_479);
+lean_ctor_set(x_483, 2, x_480);
+lean_ctor_set(x_483, 3, x_478);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+x_484 = 1;
+x_485 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_485, 0, x_483);
+lean_ctor_set(x_485, 1, x_376);
+lean_ctor_set(x_485, 2, x_377);
+lean_ctor_set(x_485, 3, x_378);
+lean_ctor_set_uint8(x_485, sizeof(void*)*4, x_484);
+return x_485;
+}
+else
+{
+uint8_t x_486; 
+x_486 = lean_ctor_get_uint8(x_478, sizeof(void*)*4);
+if (x_486 == 0)
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; uint8_t x_495; lean_object* x_496; lean_object* x_497; uint8_t x_498; lean_object* x_499; 
+x_487 = lean_ctor_get(x_476, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_476, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_489 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_489 = lean_box(0);
+}
+x_490 = lean_ctor_get(x_478, 0);
+lean_inc(x_490);
+x_491 = lean_ctor_get(x_478, 1);
+lean_inc(x_491);
+x_492 = lean_ctor_get(x_478, 2);
+lean_inc(x_492);
+x_493 = lean_ctor_get(x_478, 3);
+lean_inc(x_493);
+if (lean_is_exclusive(x_478)) {
+ lean_ctor_release(x_478, 0);
+ lean_ctor_release(x_478, 1);
+ lean_ctor_release(x_478, 2);
+ lean_ctor_release(x_478, 3);
+ x_494 = x_478;
+} else {
+ lean_dec_ref(x_478);
+ x_494 = lean_box(0);
+}
+x_495 = 1;
+if (lean_is_scalar(x_494)) {
+ x_496 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_496 = x_494;
+}
+lean_ctor_set(x_496, 0, x_477);
+lean_ctor_set(x_496, 1, x_487);
+lean_ctor_set(x_496, 2, x_488);
+lean_ctor_set(x_496, 3, x_490);
+lean_ctor_set_uint8(x_496, sizeof(void*)*4, x_495);
+if (lean_is_scalar(x_489)) {
+ x_497 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_497 = x_489;
+}
+lean_ctor_set(x_497, 0, x_493);
+lean_ctor_set(x_497, 1, x_376);
+lean_ctor_set(x_497, 2, x_377);
+lean_ctor_set(x_497, 3, x_378);
+lean_ctor_set_uint8(x_497, sizeof(void*)*4, x_495);
+x_498 = 0;
+x_499 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_499, 0, x_496);
+lean_ctor_set(x_499, 1, x_491);
+lean_ctor_set(x_499, 2, x_492);
+lean_ctor_set(x_499, 3, x_497);
+lean_ctor_set_uint8(x_499, sizeof(void*)*4, x_498);
+return x_499;
+}
+else
+{
+lean_object* x_500; lean_object* x_501; lean_object* x_502; uint8_t x_503; lean_object* x_504; uint8_t x_505; lean_object* x_506; 
+x_500 = lean_ctor_get(x_476, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_476, 2);
+lean_inc(x_501);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_502 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_502 = lean_box(0);
+}
+x_503 = 0;
+if (lean_is_scalar(x_502)) {
+ x_504 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_504 = x_502;
+}
+lean_ctor_set(x_504, 0, x_477);
+lean_ctor_set(x_504, 1, x_500);
+lean_ctor_set(x_504, 2, x_501);
+lean_ctor_set(x_504, 3, x_478);
+lean_ctor_set_uint8(x_504, sizeof(void*)*4, x_503);
+x_505 = 1;
+x_506 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_506, 0, x_504);
+lean_ctor_set(x_506, 1, x_376);
+lean_ctor_set(x_506, 2, x_377);
+lean_ctor_set(x_506, 3, x_378);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_505);
+return x_506;
+}
+}
+}
+else
+{
+uint8_t x_507; 
+x_507 = lean_ctor_get_uint8(x_477, sizeof(void*)*4);
+if (x_507 == 0)
+{
+lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; lean_object* x_516; uint8_t x_517; lean_object* x_518; lean_object* x_519; uint8_t x_520; lean_object* x_521; 
+x_508 = lean_ctor_get(x_476, 1);
+lean_inc(x_508);
+x_509 = lean_ctor_get(x_476, 2);
+lean_inc(x_509);
+x_510 = lean_ctor_get(x_476, 3);
+lean_inc(x_510);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_511 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_511 = lean_box(0);
+}
+x_512 = lean_ctor_get(x_477, 0);
+lean_inc(x_512);
+x_513 = lean_ctor_get(x_477, 1);
+lean_inc(x_513);
+x_514 = lean_ctor_get(x_477, 2);
+lean_inc(x_514);
+x_515 = lean_ctor_get(x_477, 3);
+lean_inc(x_515);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_516 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_516 = lean_box(0);
+}
+x_517 = 1;
+if (lean_is_scalar(x_516)) {
+ x_518 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_518 = x_516;
+}
+lean_ctor_set(x_518, 0, x_512);
+lean_ctor_set(x_518, 1, x_513);
+lean_ctor_set(x_518, 2, x_514);
+lean_ctor_set(x_518, 3, x_515);
+lean_ctor_set_uint8(x_518, sizeof(void*)*4, x_517);
+if (lean_is_scalar(x_511)) {
+ x_519 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_519 = x_511;
+}
+lean_ctor_set(x_519, 0, x_510);
+lean_ctor_set(x_519, 1, x_376);
+lean_ctor_set(x_519, 2, x_377);
+lean_ctor_set(x_519, 3, x_378);
+lean_ctor_set_uint8(x_519, sizeof(void*)*4, x_517);
+x_520 = 0;
+x_521 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_521, 0, x_518);
+lean_ctor_set(x_521, 1, x_508);
+lean_ctor_set(x_521, 2, x_509);
+lean_ctor_set(x_521, 3, x_519);
+lean_ctor_set_uint8(x_521, sizeof(void*)*4, x_520);
+return x_521;
+}
+else
+{
+lean_object* x_522; 
+x_522 = lean_ctor_get(x_476, 3);
+lean_inc(x_522);
+if (lean_obj_tag(x_522) == 0)
+{
+lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; uint8_t x_528; lean_object* x_529; 
+x_523 = lean_ctor_get(x_476, 1);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_476, 2);
+lean_inc(x_524);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_525 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_525 = lean_box(0);
+}
+x_526 = 0;
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_477);
+lean_ctor_set(x_527, 1, x_523);
+lean_ctor_set(x_527, 2, x_524);
+lean_ctor_set(x_527, 3, x_522);
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+x_528 = 1;
+x_529 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_529, 0, x_527);
+lean_ctor_set(x_529, 1, x_376);
+lean_ctor_set(x_529, 2, x_377);
+lean_ctor_set(x_529, 3, x_378);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_528);
+return x_529;
+}
+else
+{
+uint8_t x_530; 
+x_530 = lean_ctor_get_uint8(x_522, sizeof(void*)*4);
+if (x_530 == 0)
+{
+lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; uint8_t x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_531 = lean_ctor_get(x_476, 1);
+lean_inc(x_531);
+x_532 = lean_ctor_get(x_476, 2);
+lean_inc(x_532);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_533 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_533 = lean_box(0);
+}
+x_534 = lean_ctor_get(x_522, 0);
+lean_inc(x_534);
+x_535 = lean_ctor_get(x_522, 1);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_522, 2);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_522, 3);
+lean_inc(x_537);
+if (lean_is_exclusive(x_522)) {
+ lean_ctor_release(x_522, 0);
+ lean_ctor_release(x_522, 1);
+ lean_ctor_release(x_522, 2);
+ lean_ctor_release(x_522, 3);
+ x_538 = x_522;
+} else {
+ lean_dec_ref(x_522);
+ x_538 = lean_box(0);
+}
+x_539 = 1;
+lean_inc(x_477);
+if (lean_is_scalar(x_538)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_538;
+}
+lean_ctor_set(x_540, 0, x_477);
+lean_ctor_set(x_540, 1, x_531);
+lean_ctor_set(x_540, 2, x_532);
+lean_ctor_set(x_540, 3, x_534);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_541 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_541 = lean_box(0);
+}
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_539);
+if (lean_is_scalar(x_541)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_541;
+}
+lean_ctor_set(x_542, 0, x_537);
+lean_ctor_set(x_542, 1, x_376);
+lean_ctor_set(x_542, 2, x_377);
+lean_ctor_set(x_542, 3, x_378);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_539);
+x_543 = 0;
+if (lean_is_scalar(x_533)) {
+ x_544 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_544 = x_533;
+}
+lean_ctor_set(x_544, 0, x_540);
+lean_ctor_set(x_544, 1, x_535);
+lean_ctor_set(x_544, 2, x_536);
+lean_ctor_set(x_544, 3, x_542);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
+}
+else
+{
+lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; uint8_t x_554; lean_object* x_555; uint8_t x_556; lean_object* x_557; 
+x_545 = lean_ctor_get(x_476, 1);
+lean_inc(x_545);
+x_546 = lean_ctor_get(x_476, 2);
+lean_inc(x_546);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_547 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_547 = lean_box(0);
+}
+x_548 = lean_ctor_get(x_477, 0);
+lean_inc(x_548);
+x_549 = lean_ctor_get(x_477, 1);
+lean_inc(x_549);
+x_550 = lean_ctor_get(x_477, 2);
+lean_inc(x_550);
+x_551 = lean_ctor_get(x_477, 3);
+lean_inc(x_551);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_552 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_552 = lean_box(0);
+}
+if (lean_is_scalar(x_552)) {
+ x_553 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_553 = x_552;
+}
+lean_ctor_set(x_553, 0, x_548);
+lean_ctor_set(x_553, 1, x_549);
+lean_ctor_set(x_553, 2, x_550);
+lean_ctor_set(x_553, 3, x_551);
+lean_ctor_set_uint8(x_553, sizeof(void*)*4, x_530);
+x_554 = 0;
+if (lean_is_scalar(x_547)) {
+ x_555 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_555 = x_547;
+}
+lean_ctor_set(x_555, 0, x_553);
+lean_ctor_set(x_555, 1, x_545);
+lean_ctor_set(x_555, 2, x_546);
+lean_ctor_set(x_555, 3, x_522);
+lean_ctor_set_uint8(x_555, sizeof(void*)*4, x_554);
+x_556 = 1;
+x_557 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_557, 0, x_555);
+lean_ctor_set(x_557, 1, x_376);
+lean_ctor_set(x_557, 2, x_377);
+lean_ctor_set(x_557, 3, x_378);
+lean_ctor_set_uint8(x_557, sizeof(void*)*4, x_556);
+return x_557;
 }
 }
 }
@@ -2688,2403 +2882,2478 @@ return x_490;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; lean_object* x_6; 
-x_4 = 0;
-x_5 = lean_box_uint32(x_2);
-x_6 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_6, 0, x_1);
-lean_ctor_set(x_6, 1, x_5);
-lean_ctor_set(x_6, 2, x_3);
-lean_ctor_set(x_6, 3, x_1);
-lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_4);
-return x_6;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_box_uint32(x_2);
+x_7 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 2, x_3);
+lean_ctor_set(x_7, 3, x_4);
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_5);
+return x_7;
 }
 else
 {
-uint8_t x_7; 
-x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_7 == 0)
-{
 uint8_t x_8; 
-x_8 = !lean_is_exclusive(x_1);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_8 == 0)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint32_t x_13; uint8_t x_14; 
-x_9 = lean_ctor_get(x_1, 0);
-x_10 = lean_ctor_get(x_1, 1);
-x_11 = lean_ctor_get(x_1, 2);
-x_12 = lean_ctor_get(x_1, 3);
-x_13 = lean_unbox_uint32(x_10);
-x_14 = x_2 < x_13;
-if (x_14 == 0)
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_1);
+if (x_9 == 0)
 {
-uint32_t x_15; uint8_t x_16; 
-x_15 = lean_unbox_uint32(x_10);
-x_16 = x_15 < x_2;
-if (x_16 == 0)
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint32_t x_14; uint8_t x_15; 
+x_10 = lean_ctor_get(x_1, 0);
+x_11 = lean_ctor_get(x_1, 1);
+x_12 = lean_ctor_get(x_1, 2);
+x_13 = lean_ctor_get(x_1, 3);
+x_14 = lean_unbox_uint32(x_11);
+x_15 = x_2 < x_14;
+if (x_15 == 0)
 {
-lean_object* x_17; 
+uint32_t x_16; uint8_t x_17; 
+x_16 = lean_unbox_uint32(x_11);
+x_17 = x_16 < x_2;
+if (x_17 == 0)
+{
+uint8_t x_18; lean_object* x_19; 
+lean_dec(x_12);
 lean_dec(x_11);
-lean_dec(x_10);
-x_17 = lean_box_uint32(x_2);
+x_18 = 0;
+x_19 = lean_box_uint32(x_2);
 lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_17);
+lean_ctor_set(x_1, 1, x_19);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_18);
 return x_1;
 }
 else
 {
-lean_object* x_18; 
-x_18 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_12, x_2, x_3);
-lean_ctor_set(x_1, 3, x_18);
+lean_object* x_20; uint8_t x_21; 
+x_20 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_13, x_2, x_3);
+x_21 = 0;
+lean_ctor_set(x_1, 3, x_20);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_21);
 return x_1;
 }
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_9, x_2, x_3);
-lean_ctor_set(x_1, 0, x_19);
+lean_object* x_22; uint8_t x_23; 
+x_22 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_10, x_2, x_3);
+x_23 = 0;
+lean_ctor_set(x_1, 0, x_22);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_23);
 return x_1;
 }
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint32_t x_24; uint8_t x_25; 
-x_20 = lean_ctor_get(x_1, 0);
-x_21 = lean_ctor_get(x_1, 1);
-x_22 = lean_ctor_get(x_1, 2);
-x_23 = lean_ctor_get(x_1, 3);
-lean_inc(x_23);
-lean_inc(x_22);
-lean_inc(x_21);
-lean_inc(x_20);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint32_t x_28; uint8_t x_29; 
+x_24 = lean_ctor_get(x_1, 0);
+x_25 = lean_ctor_get(x_1, 1);
+x_26 = lean_ctor_get(x_1, 2);
+x_27 = lean_ctor_get(x_1, 3);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_inc(x_24);
 lean_dec(x_1);
-x_24 = lean_unbox_uint32(x_21);
-x_25 = x_2 < x_24;
-if (x_25 == 0)
+x_28 = lean_unbox_uint32(x_25);
+x_29 = x_2 < x_28;
+if (x_29 == 0)
 {
-uint32_t x_26; uint8_t x_27; 
-x_26 = lean_unbox_uint32(x_21);
-x_27 = x_26 < x_2;
-if (x_27 == 0)
+uint32_t x_30; uint8_t x_31; 
+x_30 = lean_unbox_uint32(x_25);
+x_31 = x_30 < x_2;
+if (x_31 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_21);
-x_28 = lean_box_uint32(x_2);
-x_29 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_29, 0, x_20);
-lean_ctor_set(x_29, 1, x_28);
-lean_ctor_set(x_29, 2, x_3);
-lean_ctor_set(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, sizeof(void*)*4, x_7);
-return x_29;
+uint8_t x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_26);
+lean_dec(x_25);
+x_32 = 0;
+x_33 = lean_box_uint32(x_2);
+x_34 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_34, 0, x_24);
+lean_ctor_set(x_34, 1, x_33);
+lean_ctor_set(x_34, 2, x_3);
+lean_ctor_set(x_34, 3, x_27);
+lean_ctor_set_uint8(x_34, sizeof(void*)*4, x_32);
+return x_34;
 }
 else
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_23, x_2, x_3);
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_20);
-lean_ctor_set(x_31, 1, x_21);
-lean_ctor_set(x_31, 2, x_22);
-lean_ctor_set(x_31, 3, x_30);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_7);
-return x_31;
+lean_object* x_35; uint8_t x_36; lean_object* x_37; 
+x_35 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_27, x_2, x_3);
+x_36 = 0;
+x_37 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_37, 0, x_24);
+lean_ctor_set(x_37, 1, x_25);
+lean_ctor_set(x_37, 2, x_26);
+lean_ctor_set(x_37, 3, x_35);
+lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
+return x_37;
 }
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_20, x_2, x_3);
-x_33 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_21);
-lean_ctor_set(x_33, 2, x_22);
-lean_ctor_set(x_33, 3, x_23);
-lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_7);
-return x_33;
+lean_object* x_38; uint8_t x_39; lean_object* x_40; 
+x_38 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_24, x_2, x_3);
+x_39 = 0;
+x_40 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_25);
+lean_ctor_set(x_40, 2, x_26);
+lean_ctor_set(x_40, 3, x_27);
+lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = !lean_is_exclusive(x_1);
-if (x_34 == 0)
+uint8_t x_41; 
+x_41 = !lean_is_exclusive(x_1);
+if (x_41 == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint32_t x_39; uint8_t x_40; 
-x_35 = lean_ctor_get(x_1, 0);
-x_36 = lean_ctor_get(x_1, 1);
-x_37 = lean_ctor_get(x_1, 2);
-x_38 = lean_ctor_get(x_1, 3);
-x_39 = lean_unbox_uint32(x_36);
-x_40 = x_2 < x_39;
-if (x_40 == 0)
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint32_t x_46; uint8_t x_47; 
+x_42 = lean_ctor_get(x_1, 0);
+x_43 = lean_ctor_get(x_1, 1);
+x_44 = lean_ctor_get(x_1, 2);
+x_45 = lean_ctor_get(x_1, 3);
+x_46 = lean_unbox_uint32(x_43);
+x_47 = x_2 < x_46;
+if (x_47 == 0)
 {
-uint32_t x_41; uint8_t x_42; 
-x_41 = lean_unbox_uint32(x_36);
-x_42 = x_41 < x_2;
-if (x_42 == 0)
-{
-lean_object* x_43; 
-lean_dec(x_37);
-lean_dec(x_36);
-x_43 = lean_box_uint32(x_2);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_43);
-return x_1;
-}
-else
-{
-uint8_t x_44; 
-x_44 = l_Std_RBNode_isRed___rarg(x_38);
-if (x_44 == 0)
-{
-lean_object* x_45; 
-x_45 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_38, x_2, x_3);
-lean_ctor_set(x_1, 3, x_45);
-return x_1;
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-x_46 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_38, x_2, x_3);
-x_47 = lean_ctor_get(x_46, 0);
-lean_inc(x_47);
-if (lean_obj_tag(x_47) == 0)
-{
-lean_object* x_48; 
-x_48 = lean_ctor_get(x_46, 3);
-lean_inc(x_48);
-if (lean_obj_tag(x_48) == 0)
-{
-uint8_t x_49; 
-x_49 = !lean_is_exclusive(x_46);
+uint32_t x_48; uint8_t x_49; 
+x_48 = lean_unbox_uint32(x_43);
+x_49 = x_48 < x_2;
 if (x_49 == 0)
 {
-lean_object* x_50; lean_object* x_51; uint8_t x_52; uint8_t x_53; 
-x_50 = lean_ctor_get(x_46, 3);
-lean_dec(x_50);
-x_51 = lean_ctor_get(x_46, 0);
-lean_dec(x_51);
-x_52 = 0;
-lean_ctor_set(x_46, 0, x_48);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_52);
-x_53 = 1;
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_53);
+uint8_t x_50; lean_object* x_51; 
+lean_dec(x_44);
+lean_dec(x_43);
+x_50 = 1;
+x_51 = lean_box_uint32(x_2);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_51);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_50);
 return x_1;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; 
-x_54 = lean_ctor_get(x_46, 1);
-x_55 = lean_ctor_get(x_46, 2);
-lean_inc(x_55);
-lean_inc(x_54);
-lean_dec(x_46);
-x_56 = 0;
-x_57 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_57, 0, x_48);
-lean_ctor_set(x_57, 1, x_54);
-lean_ctor_set(x_57, 2, x_55);
-lean_ctor_set(x_57, 3, x_48);
-lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_56);
-x_58 = 1;
-lean_ctor_set(x_1, 3, x_57);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_58);
+uint8_t x_52; 
+x_52 = l_Std_RBNode_isRed___rarg(x_45);
+if (x_52 == 0)
+{
+lean_object* x_53; uint8_t x_54; 
+x_53 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_45, x_2, x_3);
+x_54 = 1;
+lean_ctor_set(x_1, 3, x_53);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_54);
+return x_1;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_45, x_2, x_3);
+x_56 = lean_ctor_get(x_55, 0);
+lean_inc(x_56);
+if (lean_obj_tag(x_56) == 0)
+{
+lean_object* x_57; 
+x_57 = lean_ctor_get(x_55, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
+{
+uint8_t x_58; 
+x_58 = !lean_is_exclusive(x_55);
+if (x_58 == 0)
+{
+lean_object* x_59; lean_object* x_60; uint8_t x_61; uint8_t x_62; 
+x_59 = lean_ctor_get(x_55, 3);
+lean_dec(x_59);
+x_60 = lean_ctor_get(x_55, 0);
+lean_dec(x_60);
+x_61 = 0;
+lean_ctor_set(x_55, 0, x_57);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_61);
+x_62 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_62);
+return x_1;
+}
+else
+{
+lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; uint8_t x_67; 
+x_63 = lean_ctor_get(x_55, 1);
+x_64 = lean_ctor_get(x_55, 2);
+lean_inc(x_64);
+lean_inc(x_63);
+lean_dec(x_55);
+x_65 = 0;
+x_66 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_66, 0, x_57);
+lean_ctor_set(x_66, 1, x_63);
+lean_ctor_set(x_66, 2, x_64);
+lean_ctor_set(x_66, 3, x_57);
+lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
+x_67 = 1;
+lean_ctor_set(x_1, 3, x_66);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_67);
 return x_1;
 }
 }
 else
 {
-uint8_t x_59; 
-x_59 = lean_ctor_get_uint8(x_48, sizeof(void*)*4);
-if (x_59 == 0)
+uint8_t x_68; 
+x_68 = lean_ctor_get_uint8(x_57, sizeof(void*)*4);
+if (x_68 == 0)
 {
-uint8_t x_60; 
-x_60 = !lean_is_exclusive(x_46);
-if (x_60 == 0)
+uint8_t x_69; 
+x_69 = !lean_is_exclusive(x_55);
+if (x_69 == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; 
-x_61 = lean_ctor_get(x_46, 1);
-x_62 = lean_ctor_get(x_46, 2);
-x_63 = lean_ctor_get(x_46, 3);
-lean_dec(x_63);
-x_64 = lean_ctor_get(x_46, 0);
-lean_dec(x_64);
-x_65 = !lean_is_exclusive(x_48);
-if (x_65 == 0)
+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_55, 1);
+x_71 = lean_ctor_get(x_55, 2);
+x_72 = lean_ctor_get(x_55, 3);
+lean_dec(x_72);
+x_73 = lean_ctor_get(x_55, 0);
+lean_dec(x_73);
+x_74 = !lean_is_exclusive(x_57);
+if (x_74 == 0)
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; 
-x_66 = lean_ctor_get(x_48, 0);
-x_67 = lean_ctor_get(x_48, 1);
-x_68 = lean_ctor_get(x_48, 2);
-x_69 = lean_ctor_get(x_48, 3);
-x_70 = 1;
-lean_ctor_set(x_48, 3, x_47);
-lean_ctor_set(x_48, 2, x_37);
-lean_ctor_set(x_48, 1, x_36);
-lean_ctor_set(x_48, 0, x_35);
-lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_70);
-lean_ctor_set(x_46, 3, x_69);
-lean_ctor_set(x_46, 2, x_68);
-lean_ctor_set(x_46, 1, x_67);
-lean_ctor_set(x_46, 0, x_66);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_70);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_48);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; uint8_t x_80; 
+x_75 = lean_ctor_get(x_57, 0);
+x_76 = lean_ctor_get(x_57, 1);
+x_77 = lean_ctor_get(x_57, 2);
+x_78 = lean_ctor_get(x_57, 3);
+x_79 = 1;
+lean_ctor_set(x_57, 3, x_56);
+lean_ctor_set(x_57, 2, x_44);
+lean_ctor_set(x_57, 1, x_43);
+lean_ctor_set(x_57, 0, x_42);
+lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_79);
+lean_ctor_set(x_55, 3, x_78);
+lean_ctor_set(x_55, 2, x_77);
+lean_ctor_set(x_55, 1, x_76);
+lean_ctor_set(x_55, 0, x_75);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_79);
+x_80 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_57);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_80);
 return x_1;
 }
 else
 {
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; 
-x_71 = lean_ctor_get(x_48, 0);
-x_72 = lean_ctor_get(x_48, 1);
-x_73 = lean_ctor_get(x_48, 2);
-x_74 = lean_ctor_get(x_48, 3);
-lean_inc(x_74);
-lean_inc(x_73);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_dec(x_48);
-x_75 = 1;
-x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_35);
-lean_ctor_set(x_76, 1, x_36);
-lean_ctor_set(x_76, 2, x_37);
-lean_ctor_set(x_76, 3, x_47);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
-lean_ctor_set(x_46, 3, x_74);
-lean_ctor_set(x_46, 2, x_73);
-lean_ctor_set(x_46, 1, x_72);
-lean_ctor_set(x_46, 0, x_71);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_75);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_76);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-}
-else
-{
-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; uint8_t x_84; lean_object* x_85; lean_object* x_86; 
-x_77 = lean_ctor_get(x_46, 1);
-x_78 = lean_ctor_get(x_46, 2);
-lean_inc(x_78);
-lean_inc(x_77);
-lean_dec(x_46);
-x_79 = lean_ctor_get(x_48, 0);
-lean_inc(x_79);
-x_80 = lean_ctor_get(x_48, 1);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_48, 2);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_48, 3);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; lean_object* x_86; uint8_t x_87; 
+x_81 = lean_ctor_get(x_57, 0);
+x_82 = lean_ctor_get(x_57, 1);
+x_83 = lean_ctor_get(x_57, 2);
+x_84 = lean_ctor_get(x_57, 3);
+lean_inc(x_84);
+lean_inc(x_83);
 lean_inc(x_82);
-if (lean_is_exclusive(x_48)) {
- lean_ctor_release(x_48, 0);
- lean_ctor_release(x_48, 1);
- lean_ctor_release(x_48, 2);
- lean_ctor_release(x_48, 3);
- x_83 = x_48;
-} else {
- lean_dec_ref(x_48);
- x_83 = lean_box(0);
-}
-x_84 = 1;
-if (lean_is_scalar(x_83)) {
- x_85 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_85 = x_83;
-}
-lean_ctor_set(x_85, 0, x_35);
-lean_ctor_set(x_85, 1, x_36);
-lean_ctor_set(x_85, 2, x_37);
-lean_ctor_set(x_85, 3, x_47);
-lean_ctor_set_uint8(x_85, sizeof(void*)*4, x_84);
+lean_inc(x_81);
+lean_dec(x_57);
+x_85 = 1;
 x_86 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_86, 0, x_79);
-lean_ctor_set(x_86, 1, x_80);
-lean_ctor_set(x_86, 2, x_81);
-lean_ctor_set(x_86, 3, x_82);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_84);
-lean_ctor_set(x_1, 3, x_86);
-lean_ctor_set(x_1, 2, x_78);
-lean_ctor_set(x_1, 1, x_77);
-lean_ctor_set(x_1, 0, x_85);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_ctor_set(x_86, 0, x_42);
+lean_ctor_set(x_86, 1, x_43);
+lean_ctor_set(x_86, 2, x_44);
+lean_ctor_set(x_86, 3, x_56);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+lean_ctor_set(x_55, 3, x_84);
+lean_ctor_set(x_55, 2, x_83);
+lean_ctor_set(x_55, 1, x_82);
+lean_ctor_set(x_55, 0, x_81);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_85);
+x_87 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_87);
 return x_1;
 }
 }
 else
 {
-uint8_t x_87; 
-x_87 = !lean_is_exclusive(x_46);
-if (x_87 == 0)
-{
-lean_object* x_88; lean_object* x_89; uint8_t x_90; 
-x_88 = lean_ctor_get(x_46, 3);
-lean_dec(x_88);
-x_89 = lean_ctor_get(x_46, 0);
-lean_dec(x_89);
-x_90 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_90);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-else
-{
-lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; 
-x_91 = lean_ctor_get(x_46, 1);
-x_92 = lean_ctor_get(x_46, 2);
-lean_inc(x_92);
+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; uint8_t x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; 
+x_88 = lean_ctor_get(x_55, 1);
+x_89 = lean_ctor_get(x_55, 2);
+lean_inc(x_89);
+lean_inc(x_88);
+lean_dec(x_55);
+x_90 = lean_ctor_get(x_57, 0);
+lean_inc(x_90);
+x_91 = lean_ctor_get(x_57, 1);
 lean_inc(x_91);
-lean_dec(x_46);
-x_93 = 0;
-x_94 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_94, 0, x_47);
-lean_ctor_set(x_94, 1, x_91);
-lean_ctor_set(x_94, 2, x_92);
-lean_ctor_set(x_94, 3, x_48);
-lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_94);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+x_92 = lean_ctor_get(x_57, 2);
+lean_inc(x_92);
+x_93 = lean_ctor_get(x_57, 3);
+lean_inc(x_93);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ lean_ctor_release(x_57, 2);
+ lean_ctor_release(x_57, 3);
+ x_94 = x_57;
+} else {
+ lean_dec_ref(x_57);
+ x_94 = lean_box(0);
+}
+x_95 = 1;
+if (lean_is_scalar(x_94)) {
+ x_96 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_96 = x_94;
+}
+lean_ctor_set(x_96, 0, x_42);
+lean_ctor_set(x_96, 1, x_43);
+lean_ctor_set(x_96, 2, x_44);
+lean_ctor_set(x_96, 3, x_56);
+lean_ctor_set_uint8(x_96, sizeof(void*)*4, x_95);
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_90);
+lean_ctor_set(x_97, 1, x_91);
+lean_ctor_set(x_97, 2, x_92);
+lean_ctor_set(x_97, 3, x_93);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_95);
+x_98 = 0;
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set(x_1, 2, x_89);
+lean_ctor_set(x_1, 1, x_88);
+lean_ctor_set(x_1, 0, x_96);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_95; 
-x_95 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
-if (x_95 == 0)
+uint8_t x_99; 
+x_99 = !lean_is_exclusive(x_55);
+if (x_99 == 0)
 {
-uint8_t x_96; 
-x_96 = !lean_is_exclusive(x_46);
-if (x_96 == 0)
-{
-lean_object* x_97; uint8_t x_98; 
-x_97 = lean_ctor_get(x_46, 0);
-lean_dec(x_97);
-x_98 = !lean_is_exclusive(x_47);
-if (x_98 == 0)
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; uint8_t x_103; 
-x_99 = lean_ctor_get(x_47, 0);
-x_100 = lean_ctor_get(x_47, 1);
-x_101 = lean_ctor_get(x_47, 2);
-x_102 = lean_ctor_get(x_47, 3);
+lean_object* x_100; lean_object* x_101; uint8_t x_102; uint8_t x_103; 
+x_100 = lean_ctor_get(x_55, 3);
+lean_dec(x_100);
+x_101 = lean_ctor_get(x_55, 0);
+lean_dec(x_101);
+x_102 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_102);
 x_103 = 1;
-lean_ctor_set(x_47, 3, x_99);
-lean_ctor_set(x_47, 2, x_37);
-lean_ctor_set(x_47, 1, x_36);
-lean_ctor_set(x_47, 0, x_35);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_103);
-lean_ctor_set(x_46, 0, x_102);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_103);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_101);
-lean_ctor_set(x_1, 1, x_100);
-lean_ctor_set(x_1, 0, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_103);
 return x_1;
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; 
-x_104 = lean_ctor_get(x_47, 0);
-x_105 = lean_ctor_get(x_47, 1);
-x_106 = lean_ctor_get(x_47, 2);
-x_107 = lean_ctor_get(x_47, 3);
-lean_inc(x_107);
-lean_inc(x_106);
+lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; uint8_t x_108; 
+x_104 = lean_ctor_get(x_55, 1);
+x_105 = lean_ctor_get(x_55, 2);
 lean_inc(x_105);
 lean_inc(x_104);
-lean_dec(x_47);
+lean_dec(x_55);
+x_106 = 0;
+x_107 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_107, 0, x_56);
+lean_ctor_set(x_107, 1, x_104);
+lean_ctor_set(x_107, 2, x_105);
+lean_ctor_set(x_107, 3, x_57);
+lean_ctor_set_uint8(x_107, sizeof(void*)*4, x_106);
 x_108 = 1;
-x_109 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_109, 0, x_35);
-lean_ctor_set(x_109, 1, x_36);
-lean_ctor_set(x_109, 2, x_37);
-lean_ctor_set(x_109, 3, x_104);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-lean_ctor_set(x_46, 0, x_107);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_106);
-lean_ctor_set(x_1, 1, x_105);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_107);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; lean_object* x_120; 
-x_110 = lean_ctor_get(x_46, 1);
-x_111 = lean_ctor_get(x_46, 2);
-x_112 = lean_ctor_get(x_46, 3);
-lean_inc(x_112);
-lean_inc(x_111);
-lean_inc(x_110);
-lean_dec(x_46);
-x_113 = lean_ctor_get(x_47, 0);
-lean_inc(x_113);
-x_114 = lean_ctor_get(x_47, 1);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_47, 2);
-lean_inc(x_115);
-x_116 = lean_ctor_get(x_47, 3);
-lean_inc(x_116);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_117 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_117 = lean_box(0);
-}
-x_118 = 1;
-if (lean_is_scalar(x_117)) {
- x_119 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_119 = x_117;
-}
-lean_ctor_set(x_119, 0, x_35);
-lean_ctor_set(x_119, 1, x_36);
-lean_ctor_set(x_119, 2, x_37);
-lean_ctor_set(x_119, 3, x_113);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-x_120 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_120, 0, x_116);
-lean_ctor_set(x_120, 1, x_110);
-lean_ctor_set(x_120, 2, x_111);
-lean_ctor_set(x_120, 3, x_112);
-lean_ctor_set_uint8(x_120, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_120);
+uint8_t x_109; 
+x_109 = lean_ctor_get_uint8(x_56, sizeof(void*)*4);
+if (x_109 == 0)
+{
+uint8_t x_110; 
+x_110 = !lean_is_exclusive(x_55);
+if (x_110 == 0)
+{
+lean_object* x_111; uint8_t x_112; 
+x_111 = lean_ctor_get(x_55, 0);
+lean_dec(x_111);
+x_112 = !lean_is_exclusive(x_56);
+if (x_112 == 0)
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint8_t x_117; uint8_t x_118; 
+x_113 = lean_ctor_get(x_56, 0);
+x_114 = lean_ctor_get(x_56, 1);
+x_115 = lean_ctor_get(x_56, 2);
+x_116 = lean_ctor_get(x_56, 3);
+x_117 = 1;
+lean_ctor_set(x_56, 3, x_113);
+lean_ctor_set(x_56, 2, x_44);
+lean_ctor_set(x_56, 1, x_43);
+lean_ctor_set(x_56, 0, x_42);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_117);
+lean_ctor_set(x_55, 0, x_116);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_117);
+x_118 = 0;
+lean_ctor_set(x_1, 3, x_55);
 lean_ctor_set(x_1, 2, x_115);
 lean_ctor_set(x_1, 1, x_114);
-lean_ctor_set(x_1, 0, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 0, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_118);
 return x_1;
 }
-}
 else
 {
-lean_object* x_121; 
-x_121 = lean_ctor_get(x_46, 3);
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; lean_object* x_124; uint8_t x_125; 
+x_119 = lean_ctor_get(x_56, 0);
+x_120 = lean_ctor_get(x_56, 1);
+x_121 = lean_ctor_get(x_56, 2);
+x_122 = lean_ctor_get(x_56, 3);
+lean_inc(x_122);
 lean_inc(x_121);
-if (lean_obj_tag(x_121) == 0)
-{
-uint8_t x_122; 
-x_122 = !lean_is_exclusive(x_46);
-if (x_122 == 0)
-{
-lean_object* x_123; lean_object* x_124; uint8_t x_125; 
-x_123 = lean_ctor_get(x_46, 3);
-lean_dec(x_123);
-x_124 = lean_ctor_get(x_46, 0);
-lean_dec(x_124);
+lean_inc(x_120);
+lean_inc(x_119);
+lean_dec(x_56);
+x_123 = 1;
+x_124 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_124, 0, x_42);
+lean_ctor_set(x_124, 1, x_43);
+lean_ctor_set(x_124, 2, x_44);
+lean_ctor_set(x_124, 3, x_119);
+lean_ctor_set_uint8(x_124, sizeof(void*)*4, x_123);
+lean_ctor_set(x_55, 0, x_122);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_123);
 x_125 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_125);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_124);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_125);
 return x_1;
 }
+}
 else
 {
-lean_object* x_126; lean_object* x_127; uint8_t x_128; lean_object* x_129; 
-x_126 = lean_ctor_get(x_46, 1);
-x_127 = lean_ctor_get(x_46, 2);
+lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; uint8_t x_137; 
+x_126 = lean_ctor_get(x_55, 1);
+x_127 = lean_ctor_get(x_55, 2);
+x_128 = lean_ctor_get(x_55, 3);
+lean_inc(x_128);
 lean_inc(x_127);
 lean_inc(x_126);
-lean_dec(x_46);
-x_128 = 0;
-x_129 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_129, 0, x_47);
-lean_ctor_set(x_129, 1, x_126);
-lean_ctor_set(x_129, 2, x_127);
-lean_ctor_set(x_129, 3, x_121);
-lean_ctor_set_uint8(x_129, sizeof(void*)*4, x_128);
-lean_ctor_set(x_1, 3, x_129);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_dec(x_55);
+x_129 = lean_ctor_get(x_56, 0);
+lean_inc(x_129);
+x_130 = lean_ctor_get(x_56, 1);
+lean_inc(x_130);
+x_131 = lean_ctor_get(x_56, 2);
+lean_inc(x_131);
+x_132 = lean_ctor_get(x_56, 3);
+lean_inc(x_132);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_133 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_133 = lean_box(0);
+}
+x_134 = 1;
+if (lean_is_scalar(x_133)) {
+ x_135 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_135 = x_133;
+}
+lean_ctor_set(x_135, 0, x_42);
+lean_ctor_set(x_135, 1, x_43);
+lean_ctor_set(x_135, 2, x_44);
+lean_ctor_set(x_135, 3, x_129);
+lean_ctor_set_uint8(x_135, sizeof(void*)*4, x_134);
+x_136 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_136, 0, x_132);
+lean_ctor_set(x_136, 1, x_126);
+lean_ctor_set(x_136, 2, x_127);
+lean_ctor_set(x_136, 3, x_128);
+lean_ctor_set_uint8(x_136, sizeof(void*)*4, x_134);
+x_137 = 0;
+lean_ctor_set(x_1, 3, x_136);
+lean_ctor_set(x_1, 2, x_131);
+lean_ctor_set(x_1, 1, x_130);
+lean_ctor_set(x_1, 0, x_135);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_137);
 return x_1;
 }
 }
 else
 {
-uint8_t x_130; 
-x_130 = lean_ctor_get_uint8(x_121, sizeof(void*)*4);
-if (x_130 == 0)
+lean_object* x_138; 
+x_138 = lean_ctor_get(x_55, 3);
+lean_inc(x_138);
+if (lean_obj_tag(x_138) == 0)
 {
-uint8_t x_131; 
-lean_free_object(x_1);
-x_131 = !lean_is_exclusive(x_46);
-if (x_131 == 0)
-{
-lean_object* x_132; lean_object* x_133; uint8_t x_134; 
-x_132 = lean_ctor_get(x_46, 3);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_46, 0);
-lean_dec(x_133);
-x_134 = !lean_is_exclusive(x_121);
-if (x_134 == 0)
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; 
-x_135 = lean_ctor_get(x_121, 0);
-x_136 = lean_ctor_get(x_121, 1);
-x_137 = lean_ctor_get(x_121, 2);
-x_138 = lean_ctor_get(x_121, 3);
-lean_inc(x_47);
-lean_ctor_set(x_121, 3, x_47);
-lean_ctor_set(x_121, 2, x_37);
-lean_ctor_set(x_121, 1, x_36);
-lean_ctor_set(x_121, 0, x_35);
-x_139 = !lean_is_exclusive(x_47);
+uint8_t x_139; 
+x_139 = !lean_is_exclusive(x_55);
 if (x_139 == 0)
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_140 = lean_ctor_get(x_47, 3);
+lean_object* x_140; lean_object* x_141; uint8_t x_142; uint8_t x_143; 
+x_140 = lean_ctor_get(x_55, 3);
 lean_dec(x_140);
-x_141 = lean_ctor_get(x_47, 2);
+x_141 = lean_ctor_get(x_55, 0);
 lean_dec(x_141);
-x_142 = lean_ctor_get(x_47, 1);
-lean_dec(x_142);
-x_143 = lean_ctor_get(x_47, 0);
-lean_dec(x_143);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-lean_ctor_set(x_47, 3, x_138);
-lean_ctor_set(x_47, 2, x_137);
-lean_ctor_set(x_47, 1, x_136);
-lean_ctor_set(x_47, 0, x_135);
-lean_ctor_set(x_46, 3, x_47);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-else
-{
-lean_object* x_144; 
-lean_dec(x_47);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-x_144 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_144, 0, x_135);
-lean_ctor_set(x_144, 1, x_136);
-lean_ctor_set(x_144, 2, x_137);
-lean_ctor_set(x_144, 3, x_138);
-lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_144);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
-x_145 = lean_ctor_get(x_121, 0);
-x_146 = lean_ctor_get(x_121, 1);
-x_147 = lean_ctor_get(x_121, 2);
-x_148 = lean_ctor_get(x_121, 3);
-lean_inc(x_148);
-lean_inc(x_147);
-lean_inc(x_146);
-lean_inc(x_145);
-lean_dec(x_121);
-lean_inc(x_47);
-x_149 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_149, 0, x_35);
-lean_ctor_set(x_149, 1, x_36);
-lean_ctor_set(x_149, 2, x_37);
-lean_ctor_set(x_149, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_150 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_145);
-lean_ctor_set(x_151, 1, x_146);
-lean_ctor_set(x_151, 2, x_147);
-lean_ctor_set(x_151, 3, x_148);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_151);
-lean_ctor_set(x_46, 0, x_149);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
-x_152 = lean_ctor_get(x_46, 1);
-x_153 = lean_ctor_get(x_46, 2);
-lean_inc(x_153);
-lean_inc(x_152);
-lean_dec(x_46);
-x_154 = lean_ctor_get(x_121, 0);
-lean_inc(x_154);
-x_155 = lean_ctor_get(x_121, 1);
-lean_inc(x_155);
-x_156 = lean_ctor_get(x_121, 2);
-lean_inc(x_156);
-x_157 = lean_ctor_get(x_121, 3);
-lean_inc(x_157);
-if (lean_is_exclusive(x_121)) {
- lean_ctor_release(x_121, 0);
- lean_ctor_release(x_121, 1);
- lean_ctor_release(x_121, 2);
- lean_ctor_release(x_121, 3);
- x_158 = x_121;
-} else {
- lean_dec_ref(x_121);
- x_158 = lean_box(0);
-}
-lean_inc(x_47);
-if (lean_is_scalar(x_158)) {
- x_159 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_159 = x_158;
-}
-lean_ctor_set(x_159, 0, x_35);
-lean_ctor_set(x_159, 1, x_36);
-lean_ctor_set(x_159, 2, x_37);
-lean_ctor_set(x_159, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_160 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_160 = lean_box(0);
-}
-lean_ctor_set_uint8(x_159, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_160)) {
- x_161 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_161 = x_160;
-}
-lean_ctor_set(x_161, 0, x_154);
-lean_ctor_set(x_161, 1, x_155);
-lean_ctor_set(x_161, 2, x_156);
-lean_ctor_set(x_161, 3, x_157);
-lean_ctor_set_uint8(x_161, sizeof(void*)*4, x_95);
-x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_159);
-lean_ctor_set(x_162, 1, x_152);
-lean_ctor_set(x_162, 2, x_153);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_130);
-return x_162;
-}
-}
-else
-{
-uint8_t x_163; 
-x_163 = !lean_is_exclusive(x_46);
-if (x_163 == 0)
-{
-lean_object* x_164; lean_object* x_165; uint8_t x_166; 
-x_164 = lean_ctor_get(x_46, 3);
-lean_dec(x_164);
-x_165 = lean_ctor_get(x_46, 0);
-lean_dec(x_165);
-x_166 = !lean_is_exclusive(x_47);
-if (x_166 == 0)
-{
-uint8_t x_167; 
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_130);
-x_167 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_167);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
+x_142 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_142);
+x_143 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_143);
 return x_1;
 }
 else
 {
-lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; 
-x_168 = lean_ctor_get(x_47, 0);
-x_169 = lean_ctor_get(x_47, 1);
-x_170 = lean_ctor_get(x_47, 2);
-x_171 = lean_ctor_get(x_47, 3);
-lean_inc(x_171);
+lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; uint8_t x_148; 
+x_144 = lean_ctor_get(x_55, 1);
+x_145 = lean_ctor_get(x_55, 2);
+lean_inc(x_145);
+lean_inc(x_144);
+lean_dec(x_55);
+x_146 = 0;
+x_147 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_147, 0, x_56);
+lean_ctor_set(x_147, 1, x_144);
+lean_ctor_set(x_147, 2, x_145);
+lean_ctor_set(x_147, 3, x_138);
+lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_146);
+x_148 = 1;
+lean_ctor_set(x_1, 3, x_147);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_148);
+return x_1;
+}
+}
+else
+{
+uint8_t x_149; 
+x_149 = lean_ctor_get_uint8(x_138, sizeof(void*)*4);
+if (x_149 == 0)
+{
+uint8_t x_150; 
+lean_free_object(x_1);
+x_150 = !lean_is_exclusive(x_55);
+if (x_150 == 0)
+{
+lean_object* x_151; lean_object* x_152; uint8_t x_153; 
+x_151 = lean_ctor_get(x_55, 3);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_55, 0);
+lean_dec(x_152);
+x_153 = !lean_is_exclusive(x_138);
+if (x_153 == 0)
+{
+lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; uint8_t x_158; uint8_t x_159; 
+x_154 = lean_ctor_get(x_138, 0);
+x_155 = lean_ctor_get(x_138, 1);
+x_156 = lean_ctor_get(x_138, 2);
+x_157 = lean_ctor_get(x_138, 3);
+x_158 = 1;
+lean_inc(x_56);
+lean_ctor_set(x_138, 3, x_56);
+lean_ctor_set(x_138, 2, x_44);
+lean_ctor_set(x_138, 1, x_43);
+lean_ctor_set(x_138, 0, x_42);
+x_159 = !lean_is_exclusive(x_56);
+if (x_159 == 0)
+{
+lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; uint8_t x_164; 
+x_160 = lean_ctor_get(x_56, 3);
+lean_dec(x_160);
+x_161 = lean_ctor_get(x_56, 2);
+lean_dec(x_161);
+x_162 = lean_ctor_get(x_56, 1);
+lean_dec(x_162);
+x_163 = lean_ctor_get(x_56, 0);
+lean_dec(x_163);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+lean_ctor_set(x_56, 3, x_157);
+lean_ctor_set(x_56, 2, x_156);
+lean_ctor_set(x_56, 1, x_155);
+lean_ctor_set(x_56, 0, x_154);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_158);
+x_164 = 0;
+lean_ctor_set(x_55, 3, x_56);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_164);
+return x_55;
+}
+else
+{
+lean_object* x_165; uint8_t x_166; 
+lean_dec(x_56);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+x_165 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_165, 0, x_154);
+lean_ctor_set(x_165, 1, x_155);
+lean_ctor_set(x_165, 2, x_156);
+lean_ctor_set(x_165, 3, x_157);
+lean_ctor_set_uint8(x_165, sizeof(void*)*4, x_158);
+x_166 = 0;
+lean_ctor_set(x_55, 3, x_165);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_166);
+return x_55;
+}
+}
+else
+{
+lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; 
+x_167 = lean_ctor_get(x_138, 0);
+x_168 = lean_ctor_get(x_138, 1);
+x_169 = lean_ctor_get(x_138, 2);
+x_170 = lean_ctor_get(x_138, 3);
 lean_inc(x_170);
 lean_inc(x_169);
 lean_inc(x_168);
-lean_dec(x_47);
+lean_inc(x_167);
+lean_dec(x_138);
+x_171 = 1;
+lean_inc(x_56);
 x_172 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_172, 0, x_168);
-lean_ctor_set(x_172, 1, x_169);
-lean_ctor_set(x_172, 2, x_170);
-lean_ctor_set(x_172, 3, x_171);
-lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_130);
-x_173 = 0;
-lean_ctor_set(x_46, 0, x_172);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_173);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
+lean_ctor_set(x_172, 0, x_42);
+lean_ctor_set(x_172, 1, x_43);
+lean_ctor_set(x_172, 2, x_44);
+lean_ctor_set(x_172, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_173 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_173 = lean_box(0);
+}
+lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_171);
+if (lean_is_scalar(x_173)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_174 = x_173;
+}
+lean_ctor_set(x_174, 0, x_167);
+lean_ctor_set(x_174, 1, x_168);
+lean_ctor_set(x_174, 2, x_169);
+lean_ctor_set(x_174, 3, x_170);
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_171);
+x_175 = 0;
+lean_ctor_set(x_55, 3, x_174);
+lean_ctor_set(x_55, 0, x_172);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_175);
+return x_55;
 }
 }
 else
 {
-lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; uint8_t x_182; lean_object* x_183; 
-x_174 = lean_ctor_get(x_46, 1);
-x_175 = lean_ctor_get(x_46, 2);
-lean_inc(x_175);
-lean_inc(x_174);
-lean_dec(x_46);
-x_176 = lean_ctor_get(x_47, 0);
-lean_inc(x_176);
-x_177 = lean_ctor_get(x_47, 1);
+lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; uint8_t x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; uint8_t x_187; lean_object* x_188; 
+x_176 = lean_ctor_get(x_55, 1);
+x_177 = lean_ctor_get(x_55, 2);
 lean_inc(x_177);
-x_178 = lean_ctor_get(x_47, 2);
+lean_inc(x_176);
+lean_dec(x_55);
+x_178 = lean_ctor_get(x_138, 0);
 lean_inc(x_178);
-x_179 = lean_ctor_get(x_47, 3);
+x_179 = lean_ctor_get(x_138, 1);
 lean_inc(x_179);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_180 = x_47;
+x_180 = lean_ctor_get(x_138, 2);
+lean_inc(x_180);
+x_181 = lean_ctor_get(x_138, 3);
+lean_inc(x_181);
+if (lean_is_exclusive(x_138)) {
+ lean_ctor_release(x_138, 0);
+ lean_ctor_release(x_138, 1);
+ lean_ctor_release(x_138, 2);
+ lean_ctor_release(x_138, 3);
+ x_182 = x_138;
 } else {
- lean_dec_ref(x_47);
- x_180 = lean_box(0);
+ lean_dec_ref(x_138);
+ x_182 = lean_box(0);
 }
-if (lean_is_scalar(x_180)) {
- x_181 = lean_alloc_ctor(1, 4, 1);
+x_183 = 1;
+lean_inc(x_56);
+if (lean_is_scalar(x_182)) {
+ x_184 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_181 = x_180;
-}
-lean_ctor_set(x_181, 0, x_176);
-lean_ctor_set(x_181, 1, x_177);
-lean_ctor_set(x_181, 2, x_178);
-lean_ctor_set(x_181, 3, x_179);
-lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_130);
-x_182 = 0;
-x_183 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_183, 0, x_181);
-lean_ctor_set(x_183, 1, x_174);
-lean_ctor_set(x_183, 2, x_175);
-lean_ctor_set(x_183, 3, x_121);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_182);
-lean_ctor_set(x_1, 3, x_183);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
-}
-}
-}
+ x_184 = x_182;
 }
+lean_ctor_set(x_184, 0, x_42);
+lean_ctor_set(x_184, 1, x_43);
+lean_ctor_set(x_184, 2, x_44);
+lean_ctor_set(x_184, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_185 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_185 = lean_box(0);
 }
+lean_ctor_set_uint8(x_184, sizeof(void*)*4, x_183);
+if (lean_is_scalar(x_185)) {
+ x_186 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_186 = x_185;
 }
+lean_ctor_set(x_186, 0, x_178);
+lean_ctor_set(x_186, 1, x_179);
+lean_ctor_set(x_186, 2, x_180);
+lean_ctor_set(x_186, 3, x_181);
+lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_183);
+x_187 = 0;
+x_188 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_188, 0, x_184);
+lean_ctor_set(x_188, 1, x_176);
+lean_ctor_set(x_188, 2, x_177);
+lean_ctor_set(x_188, 3, x_186);
+lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_187);
+return x_188;
 }
 }
 else
 {
-uint8_t x_184; 
-x_184 = l_Std_RBNode_isRed___rarg(x_35);
-if (x_184 == 0)
-{
-lean_object* x_185; 
-x_185 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_35, x_2, x_3);
-lean_ctor_set(x_1, 0, x_185);
-return x_1;
-}
-else
-{
-lean_object* x_186; lean_object* x_187; 
-x_186 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_35, x_2, x_3);
-x_187 = lean_ctor_get(x_186, 0);
-lean_inc(x_187);
-if (lean_obj_tag(x_187) == 0)
-{
-lean_object* x_188; 
-x_188 = lean_ctor_get(x_186, 3);
-lean_inc(x_188);
-if (lean_obj_tag(x_188) == 0)
-{
 uint8_t x_189; 
-x_189 = !lean_is_exclusive(x_186);
+x_189 = !lean_is_exclusive(x_55);
 if (x_189 == 0)
 {
-lean_object* x_190; lean_object* x_191; uint8_t x_192; uint8_t x_193; 
-x_190 = lean_ctor_get(x_186, 3);
+lean_object* x_190; lean_object* x_191; uint8_t x_192; 
+x_190 = lean_ctor_get(x_55, 3);
 lean_dec(x_190);
-x_191 = lean_ctor_get(x_186, 0);
+x_191 = lean_ctor_get(x_55, 0);
 lean_dec(x_191);
-x_192 = 0;
-lean_ctor_set(x_186, 0, x_188);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_192);
-x_193 = 1;
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_193);
+x_192 = !lean_is_exclusive(x_56);
+if (x_192 == 0)
+{
+uint8_t x_193; uint8_t x_194; 
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_149);
+x_193 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_193);
+x_194 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_194);
 return x_1;
 }
 else
 {
-lean_object* x_194; lean_object* x_195; uint8_t x_196; lean_object* x_197; uint8_t x_198; 
-x_194 = lean_ctor_get(x_186, 1);
-x_195 = lean_ctor_get(x_186, 2);
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; uint8_t x_201; 
+x_195 = lean_ctor_get(x_56, 0);
+x_196 = lean_ctor_get(x_56, 1);
+x_197 = lean_ctor_get(x_56, 2);
+x_198 = lean_ctor_get(x_56, 3);
+lean_inc(x_198);
+lean_inc(x_197);
+lean_inc(x_196);
 lean_inc(x_195);
-lean_inc(x_194);
-lean_dec(x_186);
-x_196 = 0;
-x_197 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_197, 0, x_188);
-lean_ctor_set(x_197, 1, x_194);
-lean_ctor_set(x_197, 2, x_195);
-lean_ctor_set(x_197, 3, x_188);
-lean_ctor_set_uint8(x_197, sizeof(void*)*4, x_196);
-x_198 = 1;
-lean_ctor_set(x_1, 0, x_197);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_198);
+lean_dec(x_56);
+x_199 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_199, 0, x_195);
+lean_ctor_set(x_199, 1, x_196);
+lean_ctor_set(x_199, 2, x_197);
+lean_ctor_set(x_199, 3, x_198);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_149);
+x_200 = 0;
+lean_ctor_set(x_55, 0, x_199);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_200);
+x_201 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_201);
 return x_1;
 }
 }
 else
 {
-uint8_t x_199; 
-x_199 = lean_ctor_get_uint8(x_188, sizeof(void*)*4);
-if (x_199 == 0)
-{
-uint8_t x_200; 
-x_200 = !lean_is_exclusive(x_186);
-if (x_200 == 0)
-{
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; 
-x_201 = lean_ctor_get(x_186, 1);
-x_202 = lean_ctor_get(x_186, 2);
-x_203 = lean_ctor_get(x_186, 3);
-lean_dec(x_203);
-x_204 = lean_ctor_get(x_186, 0);
-lean_dec(x_204);
-x_205 = !lean_is_exclusive(x_188);
-if (x_205 == 0)
-{
-lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; 
-x_206 = lean_ctor_get(x_188, 0);
-x_207 = lean_ctor_get(x_188, 1);
-x_208 = lean_ctor_get(x_188, 2);
-x_209 = lean_ctor_get(x_188, 3);
-x_210 = 1;
-lean_ctor_set(x_188, 3, x_206);
-lean_ctor_set(x_188, 2, x_202);
-lean_ctor_set(x_188, 1, x_201);
-lean_ctor_set(x_188, 0, x_187);
-lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_210);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_209);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_210);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_208);
-lean_ctor_set(x_1, 1, x_207);
-lean_ctor_set(x_1, 0, x_188);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; lean_object* x_211; uint8_t x_212; 
+x_202 = lean_ctor_get(x_55, 1);
+x_203 = lean_ctor_get(x_55, 2);
+lean_inc(x_203);
+lean_inc(x_202);
+lean_dec(x_55);
+x_204 = lean_ctor_get(x_56, 0);
+lean_inc(x_204);
+x_205 = lean_ctor_get(x_56, 1);
+lean_inc(x_205);
+x_206 = lean_ctor_get(x_56, 2);
+lean_inc(x_206);
+x_207 = lean_ctor_get(x_56, 3);
+lean_inc(x_207);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_208 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_208 = lean_box(0);
+}
+if (lean_is_scalar(x_208)) {
+ x_209 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_209 = x_208;
+}
+lean_ctor_set(x_209, 0, x_204);
+lean_ctor_set(x_209, 1, x_205);
+lean_ctor_set(x_209, 2, x_206);
+lean_ctor_set(x_209, 3, x_207);
+lean_ctor_set_uint8(x_209, sizeof(void*)*4, x_149);
+x_210 = 0;
+x_211 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_211, 0, x_209);
+lean_ctor_set(x_211, 1, x_202);
+lean_ctor_set(x_211, 2, x_203);
+lean_ctor_set(x_211, 3, x_138);
+lean_ctor_set_uint8(x_211, sizeof(void*)*4, x_210);
+x_212 = 1;
+lean_ctor_set(x_1, 3, x_211);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_212);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; uint8_t x_215; lean_object* x_216; 
-x_211 = lean_ctor_get(x_188, 0);
-x_212 = lean_ctor_get(x_188, 1);
-x_213 = lean_ctor_get(x_188, 2);
-x_214 = lean_ctor_get(x_188, 3);
-lean_inc(x_214);
-lean_inc(x_213);
-lean_inc(x_212);
-lean_inc(x_211);
-lean_dec(x_188);
+uint8_t x_213; 
+x_213 = l_Std_RBNode_isRed___rarg(x_42);
+if (x_213 == 0)
+{
+lean_object* x_214; uint8_t x_215; 
+x_214 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_42, x_2, x_3);
 x_215 = 1;
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_187);
-lean_ctor_set(x_216, 1, x_201);
-lean_ctor_set(x_216, 2, x_202);
-lean_ctor_set(x_216, 3, x_211);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_215);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_214);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_215);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_213);
-lean_ctor_set(x_1, 1, x_212);
-lean_ctor_set(x_1, 0, x_216);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_ctor_set(x_1, 0, x_214);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_215);
 return x_1;
 }
-}
 else
 {
-lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; uint8_t x_224; lean_object* x_225; lean_object* x_226; 
-x_217 = lean_ctor_get(x_186, 1);
-x_218 = lean_ctor_get(x_186, 2);
-lean_inc(x_218);
+lean_object* x_216; lean_object* x_217; 
+x_216 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_42, x_2, x_3);
+x_217 = lean_ctor_get(x_216, 0);
 lean_inc(x_217);
-lean_dec(x_186);
-x_219 = lean_ctor_get(x_188, 0);
-lean_inc(x_219);
-x_220 = lean_ctor_get(x_188, 1);
-lean_inc(x_220);
-x_221 = lean_ctor_get(x_188, 2);
-lean_inc(x_221);
-x_222 = lean_ctor_get(x_188, 3);
-lean_inc(x_222);
-if (lean_is_exclusive(x_188)) {
- lean_ctor_release(x_188, 0);
- lean_ctor_release(x_188, 1);
- lean_ctor_release(x_188, 2);
- lean_ctor_release(x_188, 3);
- x_223 = x_188;
-} else {
- lean_dec_ref(x_188);
- x_223 = lean_box(0);
+if (lean_obj_tag(x_217) == 0)
+{
+lean_object* x_218; 
+x_218 = lean_ctor_get(x_216, 3);
+lean_inc(x_218);
+if (lean_obj_tag(x_218) == 0)
+{
+uint8_t x_219; 
+x_219 = !lean_is_exclusive(x_216);
+if (x_219 == 0)
+{
+lean_object* x_220; lean_object* x_221; uint8_t x_222; uint8_t x_223; 
+x_220 = lean_ctor_get(x_216, 3);
+lean_dec(x_220);
+x_221 = lean_ctor_get(x_216, 0);
+lean_dec(x_221);
+x_222 = 0;
+lean_ctor_set(x_216, 0, x_218);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_222);
+x_223 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_223);
+return x_1;
 }
-x_224 = 1;
-if (lean_is_scalar(x_223)) {
- x_225 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_225 = x_223;
-}
-lean_ctor_set(x_225, 0, x_187);
-lean_ctor_set(x_225, 1, x_217);
-lean_ctor_set(x_225, 2, x_218);
-lean_ctor_set(x_225, 3, x_219);
-lean_ctor_set_uint8(x_225, sizeof(void*)*4, x_224);
-x_226 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_226, 0, x_222);
-lean_ctor_set(x_226, 1, x_36);
-lean_ctor_set(x_226, 2, x_37);
-lean_ctor_set(x_226, 3, x_38);
-lean_ctor_set_uint8(x_226, sizeof(void*)*4, x_224);
-lean_ctor_set(x_1, 3, x_226);
-lean_ctor_set(x_1, 2, x_221);
-lean_ctor_set(x_1, 1, x_220);
-lean_ctor_set(x_1, 0, x_225);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+else
+{
+lean_object* x_224; lean_object* x_225; uint8_t x_226; lean_object* x_227; uint8_t x_228; 
+x_224 = lean_ctor_get(x_216, 1);
+x_225 = lean_ctor_get(x_216, 2);
+lean_inc(x_225);
+lean_inc(x_224);
+lean_dec(x_216);
+x_226 = 0;
+x_227 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_227, 0, x_218);
+lean_ctor_set(x_227, 1, x_224);
+lean_ctor_set(x_227, 2, x_225);
+lean_ctor_set(x_227, 3, x_218);
+lean_ctor_set_uint8(x_227, sizeof(void*)*4, x_226);
+x_228 = 1;
+lean_ctor_set(x_1, 0, x_227);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_228);
 return x_1;
 }
 }
 else
 {
-uint8_t x_227; 
-x_227 = !lean_is_exclusive(x_186);
-if (x_227 == 0)
+uint8_t x_229; 
+x_229 = lean_ctor_get_uint8(x_218, sizeof(void*)*4);
+if (x_229 == 0)
 {
-lean_object* x_228; lean_object* x_229; uint8_t x_230; 
-x_228 = lean_ctor_get(x_186, 3);
-lean_dec(x_228);
-x_229 = lean_ctor_get(x_186, 0);
-lean_dec(x_229);
-x_230 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_230);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-else
+uint8_t x_230; 
+x_230 = !lean_is_exclusive(x_216);
+if (x_230 == 0)
 {
-lean_object* x_231; lean_object* x_232; uint8_t x_233; lean_object* x_234; 
-x_231 = lean_ctor_get(x_186, 1);
-x_232 = lean_ctor_get(x_186, 2);
-lean_inc(x_232);
-lean_inc(x_231);
-lean_dec(x_186);
-x_233 = 0;
-x_234 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_234, 0, x_187);
-lean_ctor_set(x_234, 1, x_231);
-lean_ctor_set(x_234, 2, x_232);
-lean_ctor_set(x_234, 3, x_188);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_233);
-lean_ctor_set(x_1, 0, x_234);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_235; 
-x_235 = lean_ctor_get_uint8(x_187, sizeof(void*)*4);
+lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; uint8_t x_235; 
+x_231 = lean_ctor_get(x_216, 1);
+x_232 = lean_ctor_get(x_216, 2);
+x_233 = lean_ctor_get(x_216, 3);
+lean_dec(x_233);
+x_234 = lean_ctor_get(x_216, 0);
+lean_dec(x_234);
+x_235 = !lean_is_exclusive(x_218);
 if (x_235 == 0)
 {
-uint8_t x_236; 
-x_236 = !lean_is_exclusive(x_186);
-if (x_236 == 0)
-{
-lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; uint8_t x_241; 
-x_237 = lean_ctor_get(x_186, 1);
-x_238 = lean_ctor_get(x_186, 2);
-x_239 = lean_ctor_get(x_186, 3);
-x_240 = lean_ctor_get(x_186, 0);
-lean_dec(x_240);
-x_241 = !lean_is_exclusive(x_187);
-if (x_241 == 0)
-{
-uint8_t x_242; 
-x_242 = 1;
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_242);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_242);
-lean_ctor_set(x_1, 3, x_186);
+lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; uint8_t x_240; uint8_t x_241; 
+x_236 = lean_ctor_get(x_218, 0);
+x_237 = lean_ctor_get(x_218, 1);
+x_238 = lean_ctor_get(x_218, 2);
+x_239 = lean_ctor_get(x_218, 3);
+x_240 = 1;
+lean_ctor_set(x_218, 3, x_236);
+lean_ctor_set(x_218, 2, x_232);
+lean_ctor_set(x_218, 1, x_231);
+lean_ctor_set(x_218, 0, x_217);
+lean_ctor_set_uint8(x_218, sizeof(void*)*4, x_240);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_239);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_240);
+x_241 = 0;
+lean_ctor_set(x_1, 3, x_216);
 lean_ctor_set(x_1, 2, x_238);
 lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_1, 0, x_218);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_241);
 return x_1;
 }
 else
 {
-lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; 
-x_243 = lean_ctor_get(x_187, 0);
-x_244 = lean_ctor_get(x_187, 1);
-x_245 = lean_ctor_get(x_187, 2);
-x_246 = lean_ctor_get(x_187, 3);
-lean_inc(x_246);
+lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; uint8_t x_248; 
+x_242 = lean_ctor_get(x_218, 0);
+x_243 = lean_ctor_get(x_218, 1);
+x_244 = lean_ctor_get(x_218, 2);
+x_245 = lean_ctor_get(x_218, 3);
 lean_inc(x_245);
 lean_inc(x_244);
 lean_inc(x_243);
-lean_dec(x_187);
-x_247 = 1;
-x_248 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_248, 0, x_243);
-lean_ctor_set(x_248, 1, x_244);
-lean_ctor_set(x_248, 2, x_245);
-lean_ctor_set(x_248, 3, x_246);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_238);
-lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_inc(x_242);
+lean_dec(x_218);
+x_246 = 1;
+x_247 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_247, 0, x_217);
+lean_ctor_set(x_247, 1, x_231);
+lean_ctor_set(x_247, 2, x_232);
+lean_ctor_set(x_247, 3, x_242);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_245);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_246);
+x_248 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_244);
+lean_ctor_set(x_1, 1, x_243);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_248);
 return x_1;
 }
 }
 else
 {
-lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; lean_object* x_259; 
-x_249 = lean_ctor_get(x_186, 1);
-x_250 = lean_ctor_get(x_186, 2);
-x_251 = lean_ctor_get(x_186, 3);
-lean_inc(x_251);
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; lean_object* x_257; lean_object* x_258; uint8_t x_259; 
+x_249 = lean_ctor_get(x_216, 1);
+x_250 = lean_ctor_get(x_216, 2);
 lean_inc(x_250);
 lean_inc(x_249);
-lean_dec(x_186);
-x_252 = lean_ctor_get(x_187, 0);
+lean_dec(x_216);
+x_251 = lean_ctor_get(x_218, 0);
+lean_inc(x_251);
+x_252 = lean_ctor_get(x_218, 1);
 lean_inc(x_252);
-x_253 = lean_ctor_get(x_187, 1);
+x_253 = lean_ctor_get(x_218, 2);
 lean_inc(x_253);
-x_254 = lean_ctor_get(x_187, 2);
+x_254 = lean_ctor_get(x_218, 3);
 lean_inc(x_254);
-x_255 = lean_ctor_get(x_187, 3);
-lean_inc(x_255);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_256 = x_187;
+if (lean_is_exclusive(x_218)) {
+ lean_ctor_release(x_218, 0);
+ lean_ctor_release(x_218, 1);
+ lean_ctor_release(x_218, 2);
+ lean_ctor_release(x_218, 3);
+ x_255 = x_218;
 } else {
- lean_dec_ref(x_187);
- x_256 = lean_box(0);
+ lean_dec_ref(x_218);
+ x_255 = lean_box(0);
 }
-x_257 = 1;
-if (lean_is_scalar(x_256)) {
- x_258 = lean_alloc_ctor(1, 4, 1);
+x_256 = 1;
+if (lean_is_scalar(x_255)) {
+ x_257 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_258 = x_256;
+ x_257 = x_255;
 }
-lean_ctor_set(x_258, 0, x_252);
-lean_ctor_set(x_258, 1, x_253);
-lean_ctor_set(x_258, 2, x_254);
-lean_ctor_set(x_258, 3, x_255);
-lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
-x_259 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_259, 0, x_251);
-lean_ctor_set(x_259, 1, x_36);
-lean_ctor_set(x_259, 2, x_37);
-lean_ctor_set(x_259, 3, x_38);
-lean_ctor_set_uint8(x_259, sizeof(void*)*4, x_257);
-lean_ctor_set(x_1, 3, x_259);
-lean_ctor_set(x_1, 2, x_250);
-lean_ctor_set(x_1, 1, x_249);
-lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_257, 0, x_217);
+lean_ctor_set(x_257, 1, x_249);
+lean_ctor_set(x_257, 2, x_250);
+lean_ctor_set(x_257, 3, x_251);
+lean_ctor_set_uint8(x_257, sizeof(void*)*4, x_256);
+x_258 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_258, 0, x_254);
+lean_ctor_set(x_258, 1, x_43);
+lean_ctor_set(x_258, 2, x_44);
+lean_ctor_set(x_258, 3, x_45);
+lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_256);
+x_259 = 0;
+lean_ctor_set(x_1, 3, x_258);
+lean_ctor_set(x_1, 2, x_253);
+lean_ctor_set(x_1, 1, x_252);
+lean_ctor_set(x_1, 0, x_257);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
 return x_1;
 }
 }
 else
 {
-lean_object* x_260; 
-x_260 = lean_ctor_get(x_186, 3);
-lean_inc(x_260);
-if (lean_obj_tag(x_260) == 0)
+uint8_t x_260; 
+x_260 = !lean_is_exclusive(x_216);
+if (x_260 == 0)
 {
-uint8_t x_261; 
-x_261 = !lean_is_exclusive(x_186);
-if (x_261 == 0)
-{
-lean_object* x_262; lean_object* x_263; uint8_t x_264; 
-x_262 = lean_ctor_get(x_186, 3);
+lean_object* x_261; lean_object* x_262; uint8_t x_263; uint8_t x_264; 
+x_261 = lean_ctor_get(x_216, 3);
+lean_dec(x_261);
+x_262 = lean_ctor_get(x_216, 0);
 lean_dec(x_262);
-x_263 = lean_ctor_get(x_186, 0);
-lean_dec(x_263);
-x_264 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_264);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+x_263 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_263);
+x_264 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_264);
 return x_1;
 }
 else
 {
-lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; 
-x_265 = lean_ctor_get(x_186, 1);
-x_266 = lean_ctor_get(x_186, 2);
+lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; uint8_t x_269; 
+x_265 = lean_ctor_get(x_216, 1);
+x_266 = lean_ctor_get(x_216, 2);
 lean_inc(x_266);
 lean_inc(x_265);
-lean_dec(x_186);
+lean_dec(x_216);
 x_267 = 0;
 x_268 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_268, 0, x_187);
+lean_ctor_set(x_268, 0, x_217);
 lean_ctor_set(x_268, 1, x_265);
 lean_ctor_set(x_268, 2, x_266);
-lean_ctor_set(x_268, 3, x_260);
+lean_ctor_set(x_268, 3, x_218);
 lean_ctor_set_uint8(x_268, sizeof(void*)*4, x_267);
+x_269 = 1;
 lean_ctor_set(x_1, 0, x_268);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_270; 
+x_270 = lean_ctor_get_uint8(x_217, sizeof(void*)*4);
+if (x_270 == 0)
+{
+uint8_t x_271; 
+x_271 = !lean_is_exclusive(x_216);
+if (x_271 == 0)
+{
+lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; uint8_t x_276; 
+x_272 = lean_ctor_get(x_216, 1);
+x_273 = lean_ctor_get(x_216, 2);
+x_274 = lean_ctor_get(x_216, 3);
+x_275 = lean_ctor_get(x_216, 0);
+lean_dec(x_275);
+x_276 = !lean_is_exclusive(x_217);
+if (x_276 == 0)
+{
+uint8_t x_277; uint8_t x_278; 
+x_277 = 1;
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_277);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_277);
+x_278 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_278);
+return x_1;
+}
+else
+{
+lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; uint8_t x_283; lean_object* x_284; uint8_t x_285; 
+x_279 = lean_ctor_get(x_217, 0);
+x_280 = lean_ctor_get(x_217, 1);
+x_281 = lean_ctor_get(x_217, 2);
+x_282 = lean_ctor_get(x_217, 3);
+lean_inc(x_282);
+lean_inc(x_281);
+lean_inc(x_280);
+lean_inc(x_279);
+lean_dec(x_217);
+x_283 = 1;
+x_284 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_284, 0, x_279);
+lean_ctor_set(x_284, 1, x_280);
+lean_ctor_set(x_284, 2, x_281);
+lean_ctor_set(x_284, 3, x_282);
+lean_ctor_set_uint8(x_284, sizeof(void*)*4, x_283);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_283);
+x_285 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_284);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_285);
 return x_1;
 }
 }
 else
 {
-uint8_t x_269; 
-x_269 = lean_ctor_get_uint8(x_260, sizeof(void*)*4);
-if (x_269 == 0)
-{
-uint8_t x_270; 
-lean_free_object(x_1);
-x_270 = !lean_is_exclusive(x_186);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; uint8_t x_275; 
-x_271 = lean_ctor_get(x_186, 1);
-x_272 = lean_ctor_get(x_186, 2);
-x_273 = lean_ctor_get(x_186, 3);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_186, 0);
-lean_dec(x_274);
-x_275 = !lean_is_exclusive(x_260);
-if (x_275 == 0)
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; uint8_t x_280; 
-x_276 = lean_ctor_get(x_260, 0);
-x_277 = lean_ctor_get(x_260, 1);
-x_278 = lean_ctor_get(x_260, 2);
-x_279 = lean_ctor_get(x_260, 3);
-lean_inc(x_187);
-lean_ctor_set(x_260, 3, x_276);
-lean_ctor_set(x_260, 2, x_272);
-lean_ctor_set(x_260, 1, x_271);
-lean_ctor_set(x_260, 0, x_187);
-x_280 = !lean_is_exclusive(x_187);
-if (x_280 == 0)
-{
-lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; 
-x_281 = lean_ctor_get(x_187, 3);
-lean_dec(x_281);
-x_282 = lean_ctor_get(x_187, 2);
-lean_dec(x_282);
-x_283 = lean_ctor_get(x_187, 1);
-lean_dec(x_283);
-x_284 = lean_ctor_get(x_187, 0);
-lean_dec(x_284);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-lean_ctor_set(x_187, 3, x_38);
-lean_ctor_set(x_187, 2, x_37);
-lean_ctor_set(x_187, 1, x_36);
-lean_ctor_set(x_187, 0, x_279);
-lean_ctor_set(x_186, 3, x_187);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-else
-{
-lean_object* x_285; 
-lean_dec(x_187);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-x_285 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_285, 0, x_279);
-lean_ctor_set(x_285, 1, x_36);
-lean_ctor_set(x_285, 2, x_37);
-lean_ctor_set(x_285, 3, x_38);
-lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_285);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-}
-else
-{
-lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; 
-x_286 = lean_ctor_get(x_260, 0);
-x_287 = lean_ctor_get(x_260, 1);
-x_288 = lean_ctor_get(x_260, 2);
-x_289 = lean_ctor_get(x_260, 3);
-lean_inc(x_289);
+lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; uint8_t x_294; lean_object* x_295; lean_object* x_296; uint8_t x_297; 
+x_286 = lean_ctor_get(x_216, 1);
+x_287 = lean_ctor_get(x_216, 2);
+x_288 = lean_ctor_get(x_216, 3);
 lean_inc(x_288);
 lean_inc(x_287);
 lean_inc(x_286);
-lean_dec(x_260);
-lean_inc(x_187);
-x_290 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_290, 0, x_187);
-lean_ctor_set(x_290, 1, x_271);
-lean_ctor_set(x_290, 2, x_272);
-lean_ctor_set(x_290, 3, x_286);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_291 = x_187;
+lean_dec(x_216);
+x_289 = lean_ctor_get(x_217, 0);
+lean_inc(x_289);
+x_290 = lean_ctor_get(x_217, 1);
+lean_inc(x_290);
+x_291 = lean_ctor_get(x_217, 2);
+lean_inc(x_291);
+x_292 = lean_ctor_get(x_217, 3);
+lean_inc(x_292);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_293 = x_217;
 } else {
- lean_dec_ref(x_187);
- x_291 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_293 = lean_box(0);
 }
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
+x_294 = 1;
+if (lean_is_scalar(x_293)) {
+ x_295 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_292 = x_291;
+ x_295 = x_293;
 }
-lean_ctor_set(x_292, 0, x_289);
-lean_ctor_set(x_292, 1, x_36);
-lean_ctor_set(x_292, 2, x_37);
-lean_ctor_set(x_292, 3, x_38);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_292);
-lean_ctor_set(x_186, 2, x_288);
-lean_ctor_set(x_186, 1, x_287);
-lean_ctor_set(x_186, 0, x_290);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
+lean_ctor_set(x_295, 0, x_289);
+lean_ctor_set(x_295, 1, x_290);
+lean_ctor_set(x_295, 2, x_291);
+lean_ctor_set(x_295, 3, x_292);
+lean_ctor_set_uint8(x_295, sizeof(void*)*4, x_294);
+x_296 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_296, 0, x_288);
+lean_ctor_set(x_296, 1, x_43);
+lean_ctor_set(x_296, 2, x_44);
+lean_ctor_set(x_296, 3, x_45);
+lean_ctor_set_uint8(x_296, sizeof(void*)*4, x_294);
+x_297 = 0;
+lean_ctor_set(x_1, 3, x_296);
+lean_ctor_set(x_1, 2, x_287);
+lean_ctor_set(x_1, 1, x_286);
+lean_ctor_set(x_1, 0, x_295);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_297);
+return x_1;
 }
 }
 else
 {
-lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; 
-x_293 = lean_ctor_get(x_186, 1);
-x_294 = lean_ctor_get(x_186, 2);
-lean_inc(x_294);
-lean_inc(x_293);
-lean_dec(x_186);
-x_295 = lean_ctor_get(x_260, 0);
-lean_inc(x_295);
-x_296 = lean_ctor_get(x_260, 1);
-lean_inc(x_296);
-x_297 = lean_ctor_get(x_260, 2);
-lean_inc(x_297);
-x_298 = lean_ctor_get(x_260, 3);
+lean_object* x_298; 
+x_298 = lean_ctor_get(x_216, 3);
 lean_inc(x_298);
-if (lean_is_exclusive(x_260)) {
- lean_ctor_release(x_260, 0);
- lean_ctor_release(x_260, 1);
- lean_ctor_release(x_260, 2);
- lean_ctor_release(x_260, 3);
- x_299 = x_260;
-} else {
- lean_dec_ref(x_260);
- x_299 = lean_box(0);
-}
-lean_inc(x_187);
-if (lean_is_scalar(x_299)) {
- x_300 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_300 = x_299;
-}
-lean_ctor_set(x_300, 0, x_187);
-lean_ctor_set(x_300, 1, x_293);
-lean_ctor_set(x_300, 2, x_294);
-lean_ctor_set(x_300, 3, x_295);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_301 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_301 = lean_box(0);
-}
-lean_ctor_set_uint8(x_300, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_301)) {
- x_302 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_302 = x_301;
-}
-lean_ctor_set(x_302, 0, x_298);
-lean_ctor_set(x_302, 1, x_36);
-lean_ctor_set(x_302, 2, x_37);
-lean_ctor_set(x_302, 3, x_38);
-lean_ctor_set_uint8(x_302, sizeof(void*)*4, x_235);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_300);
-lean_ctor_set(x_303, 1, x_296);
-lean_ctor_set(x_303, 2, x_297);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_269);
-return x_303;
-}
-}
-else
+if (lean_obj_tag(x_298) == 0)
 {
-uint8_t x_304; 
-x_304 = !lean_is_exclusive(x_186);
-if (x_304 == 0)
+uint8_t x_299; 
+x_299 = !lean_is_exclusive(x_216);
+if (x_299 == 0)
 {
-lean_object* x_305; lean_object* x_306; uint8_t x_307; 
-x_305 = lean_ctor_get(x_186, 3);
-lean_dec(x_305);
-x_306 = lean_ctor_get(x_186, 0);
-lean_dec(x_306);
-x_307 = !lean_is_exclusive(x_187);
-if (x_307 == 0)
-{
-uint8_t x_308; 
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_269);
-x_308 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_308);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_300; lean_object* x_301; uint8_t x_302; uint8_t x_303; 
+x_300 = lean_ctor_get(x_216, 3);
+lean_dec(x_300);
+x_301 = lean_ctor_get(x_216, 0);
+lean_dec(x_301);
+x_302 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_302);
+x_303 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_303);
 return x_1;
 }
 else
 {
-lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; uint8_t x_314; 
-x_309 = lean_ctor_get(x_187, 0);
-x_310 = lean_ctor_get(x_187, 1);
-x_311 = lean_ctor_get(x_187, 2);
-x_312 = lean_ctor_get(x_187, 3);
-lean_inc(x_312);
-lean_inc(x_311);
-lean_inc(x_310);
-lean_inc(x_309);
-lean_dec(x_187);
-x_313 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_313, 0, x_309);
-lean_ctor_set(x_313, 1, x_310);
-lean_ctor_set(x_313, 2, x_311);
-lean_ctor_set(x_313, 3, x_312);
-lean_ctor_set_uint8(x_313, sizeof(void*)*4, x_269);
-x_314 = 0;
-lean_ctor_set(x_186, 0, x_313);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_314);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_304; lean_object* x_305; uint8_t x_306; lean_object* x_307; uint8_t x_308; 
+x_304 = lean_ctor_get(x_216, 1);
+x_305 = lean_ctor_get(x_216, 2);
+lean_inc(x_305);
+lean_inc(x_304);
+lean_dec(x_216);
+x_306 = 0;
+x_307 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_307, 0, x_217);
+lean_ctor_set(x_307, 1, x_304);
+lean_ctor_set(x_307, 2, x_305);
+lean_ctor_set(x_307, 3, x_298);
+lean_ctor_set_uint8(x_307, sizeof(void*)*4, x_306);
+x_308 = 1;
+lean_ctor_set(x_1, 0, x_307);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_308);
 return x_1;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; 
-x_315 = lean_ctor_get(x_186, 1);
-x_316 = lean_ctor_get(x_186, 2);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_186);
-x_317 = lean_ctor_get(x_187, 0);
-lean_inc(x_317);
-x_318 = lean_ctor_get(x_187, 1);
-lean_inc(x_318);
-x_319 = lean_ctor_get(x_187, 2);
-lean_inc(x_319);
-x_320 = lean_ctor_get(x_187, 3);
-lean_inc(x_320);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_321 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_321 = lean_box(0);
-}
-if (lean_is_scalar(x_321)) {
- x_322 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_322 = x_321;
-}
-lean_ctor_set(x_322, 0, x_317);
-lean_ctor_set(x_322, 1, x_318);
-lean_ctor_set(x_322, 2, x_319);
-lean_ctor_set(x_322, 3, x_320);
-lean_ctor_set_uint8(x_322, sizeof(void*)*4, x_269);
-x_323 = 0;
-x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_322);
-lean_ctor_set(x_324, 1, x_315);
-lean_ctor_set(x_324, 2, x_316);
-lean_ctor_set(x_324, 3, x_260);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
-lean_ctor_set(x_1, 0, x_324);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_309; 
+x_309 = lean_ctor_get_uint8(x_298, sizeof(void*)*4);
+if (x_309 == 0)
+{
+uint8_t x_310; 
+lean_free_object(x_1);
+x_310 = !lean_is_exclusive(x_216);
+if (x_310 == 0)
+{
+lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; uint8_t x_315; 
+x_311 = lean_ctor_get(x_216, 1);
+x_312 = lean_ctor_get(x_216, 2);
+x_313 = lean_ctor_get(x_216, 3);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_216, 0);
+lean_dec(x_314);
+x_315 = !lean_is_exclusive(x_298);
+if (x_315 == 0)
+{
+lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; uint8_t x_320; uint8_t x_321; 
+x_316 = lean_ctor_get(x_298, 0);
+x_317 = lean_ctor_get(x_298, 1);
+x_318 = lean_ctor_get(x_298, 2);
+x_319 = lean_ctor_get(x_298, 3);
+x_320 = 1;
+lean_inc(x_217);
+lean_ctor_set(x_298, 3, x_316);
+lean_ctor_set(x_298, 2, x_312);
+lean_ctor_set(x_298, 1, x_311);
+lean_ctor_set(x_298, 0, x_217);
+x_321 = !lean_is_exclusive(x_217);
+if (x_321 == 0)
+{
+lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; uint8_t x_326; 
+x_322 = lean_ctor_get(x_217, 3);
+lean_dec(x_322);
+x_323 = lean_ctor_get(x_217, 2);
+lean_dec(x_323);
+x_324 = lean_ctor_get(x_217, 1);
+lean_dec(x_324);
+x_325 = lean_ctor_get(x_217, 0);
+lean_dec(x_325);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+lean_ctor_set(x_217, 3, x_45);
+lean_ctor_set(x_217, 2, x_44);
+lean_ctor_set(x_217, 1, x_43);
+lean_ctor_set(x_217, 0, x_319);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_320);
+x_326 = 0;
+lean_ctor_set(x_216, 3, x_217);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_326);
+return x_216;
 }
+else
+{
+lean_object* x_327; uint8_t x_328; 
+lean_dec(x_217);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+x_327 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_327, 0, x_319);
+lean_ctor_set(x_327, 1, x_43);
+lean_ctor_set(x_327, 2, x_44);
+lean_ctor_set(x_327, 3, x_45);
+lean_ctor_set_uint8(x_327, sizeof(void*)*4, x_320);
+x_328 = 0;
+lean_ctor_set(x_216, 3, x_327);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_328);
+return x_216;
 }
 }
 else
 {
-lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; uint32_t x_329; uint8_t x_330; 
-x_325 = lean_ctor_get(x_1, 0);
-x_326 = lean_ctor_get(x_1, 1);
-x_327 = lean_ctor_get(x_1, 2);
-x_328 = lean_ctor_get(x_1, 3);
-lean_inc(x_328);
-lean_inc(x_327);
-lean_inc(x_326);
-lean_inc(x_325);
-lean_dec(x_1);
-x_329 = lean_unbox_uint32(x_326);
-x_330 = x_2 < x_329;
-if (x_330 == 0)
-{
-uint32_t x_331; uint8_t x_332; 
-x_331 = lean_unbox_uint32(x_326);
-x_332 = x_331 < x_2;
-if (x_332 == 0)
-{
-lean_object* x_333; lean_object* x_334; 
-lean_dec(x_327);
-lean_dec(x_326);
-x_333 = lean_box_uint32(x_2);
+lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; uint8_t x_337; 
+x_329 = lean_ctor_get(x_298, 0);
+x_330 = lean_ctor_get(x_298, 1);
+x_331 = lean_ctor_get(x_298, 2);
+x_332 = lean_ctor_get(x_298, 3);
+lean_inc(x_332);
+lean_inc(x_331);
+lean_inc(x_330);
+lean_inc(x_329);
+lean_dec(x_298);
+x_333 = 1;
+lean_inc(x_217);
 x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_325);
-lean_ctor_set(x_334, 1, x_333);
-lean_ctor_set(x_334, 2, x_3);
-lean_ctor_set(x_334, 3, x_328);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_7);
-return x_334;
+lean_ctor_set(x_334, 0, x_217);
+lean_ctor_set(x_334, 1, x_311);
+lean_ctor_set(x_334, 2, x_312);
+lean_ctor_set(x_334, 3, x_329);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_335 = x_217;
+} else {
+ lean_dec_ref(x_217);
+ x_335 = lean_box(0);
+}
+lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
+if (lean_is_scalar(x_335)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_336 = x_335;
+}
+lean_ctor_set(x_336, 0, x_332);
+lean_ctor_set(x_336, 1, x_43);
+lean_ctor_set(x_336, 2, x_44);
+lean_ctor_set(x_336, 3, x_45);
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_333);
+x_337 = 0;
+lean_ctor_set(x_216, 3, x_336);
+lean_ctor_set(x_216, 2, x_331);
+lean_ctor_set(x_216, 1, x_330);
+lean_ctor_set(x_216, 0, x_334);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_337);
+return x_216;
+}
 }
 else
 {
-uint8_t x_335; 
-x_335 = l_Std_RBNode_isRed___rarg(x_328);
-if (x_335 == 0)
-{
-lean_object* x_336; lean_object* x_337; 
-x_336 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_328, x_2, x_3);
-x_337 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_337, 0, x_325);
-lean_ctor_set(x_337, 1, x_326);
-lean_ctor_set(x_337, 2, x_327);
-lean_ctor_set(x_337, 3, x_336);
-lean_ctor_set_uint8(x_337, sizeof(void*)*4, x_7);
-return x_337;
-}
-else
-{
-lean_object* x_338; lean_object* x_339; 
-x_338 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_328, x_2, x_3);
-x_339 = lean_ctor_get(x_338, 0);
+lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; uint8_t x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; uint8_t x_349; lean_object* x_350; 
+x_338 = lean_ctor_get(x_216, 1);
+x_339 = lean_ctor_get(x_216, 2);
 lean_inc(x_339);
-if (lean_obj_tag(x_339) == 0)
-{
-lean_object* x_340; 
-x_340 = lean_ctor_get(x_338, 3);
+lean_inc(x_338);
+lean_dec(x_216);
+x_340 = lean_ctor_get(x_298, 0);
 lean_inc(x_340);
-if (lean_obj_tag(x_340) == 0)
-{
-lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; uint8_t x_346; lean_object* x_347; 
-x_341 = lean_ctor_get(x_338, 1);
+x_341 = lean_ctor_get(x_298, 1);
 lean_inc(x_341);
-x_342 = lean_ctor_get(x_338, 2);
+x_342 = lean_ctor_get(x_298, 2);
 lean_inc(x_342);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_343 = x_338;
+x_343 = lean_ctor_get(x_298, 3);
+lean_inc(x_343);
+if (lean_is_exclusive(x_298)) {
+ lean_ctor_release(x_298, 0);
+ lean_ctor_release(x_298, 1);
+ lean_ctor_release(x_298, 2);
+ lean_ctor_release(x_298, 3);
+ x_344 = x_298;
 } else {
- lean_dec_ref(x_338);
- x_343 = lean_box(0);
+ lean_dec_ref(x_298);
+ x_344 = lean_box(0);
 }
-x_344 = 0;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
+x_345 = 1;
+lean_inc(x_217);
+if (lean_is_scalar(x_344)) {
+ x_346 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_345 = x_343;
+ x_346 = x_344;
 }
-lean_ctor_set(x_345, 0, x_340);
-lean_ctor_set(x_345, 1, x_341);
-lean_ctor_set(x_345, 2, x_342);
-lean_ctor_set(x_345, 3, x_340);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-x_346 = 1;
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_325);
-lean_ctor_set(x_347, 1, x_326);
-lean_ctor_set(x_347, 2, x_327);
-lean_ctor_set(x_347, 3, x_345);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_346);
-return x_347;
-}
-else
-{
-uint8_t x_348; 
-x_348 = lean_ctor_get_uint8(x_340, sizeof(void*)*4);
-if (x_348 == 0)
-{
-lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; uint8_t x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; 
-x_349 = lean_ctor_get(x_338, 1);
-lean_inc(x_349);
-x_350 = lean_ctor_get(x_338, 2);
-lean_inc(x_350);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_351 = x_338;
+lean_ctor_set(x_346, 0, x_217);
+lean_ctor_set(x_346, 1, x_338);
+lean_ctor_set(x_346, 2, x_339);
+lean_ctor_set(x_346, 3, x_340);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_347 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_351 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_347 = lean_box(0);
 }
-x_352 = lean_ctor_get(x_340, 0);
-lean_inc(x_352);
-x_353 = lean_ctor_get(x_340, 1);
-lean_inc(x_353);
-x_354 = lean_ctor_get(x_340, 2);
-lean_inc(x_354);
-x_355 = lean_ctor_get(x_340, 3);
-lean_inc(x_355);
-if (lean_is_exclusive(x_340)) {
- lean_ctor_release(x_340, 0);
- lean_ctor_release(x_340, 1);
- lean_ctor_release(x_340, 2);
- lean_ctor_release(x_340, 3);
- x_356 = x_340;
+lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_345);
+if (lean_is_scalar(x_347)) {
+ x_348 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_340);
- x_356 = lean_box(0);
-}
-x_357 = 1;
-if (lean_is_scalar(x_356)) {
- x_358 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_358 = x_356;
-}
-lean_ctor_set(x_358, 0, x_325);
-lean_ctor_set(x_358, 1, x_326);
-lean_ctor_set(x_358, 2, x_327);
-lean_ctor_set(x_358, 3, x_339);
-lean_ctor_set_uint8(x_358, sizeof(void*)*4, x_357);
-if (lean_is_scalar(x_351)) {
- x_359 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_359 = x_351;
-}
-lean_ctor_set(x_359, 0, x_352);
-lean_ctor_set(x_359, 1, x_353);
-lean_ctor_set(x_359, 2, x_354);
-lean_ctor_set(x_359, 3, x_355);
-lean_ctor_set_uint8(x_359, sizeof(void*)*4, x_357);
-x_360 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_360, 0, x_358);
-lean_ctor_set(x_360, 1, x_349);
-lean_ctor_set(x_360, 2, x_350);
-lean_ctor_set(x_360, 3, x_359);
-lean_ctor_set_uint8(x_360, sizeof(void*)*4, x_348);
-return x_360;
-}
-else
-{
-lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; 
-x_361 = lean_ctor_get(x_338, 1);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_338, 2);
-lean_inc(x_362);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_363 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_363 = lean_box(0);
-}
-x_364 = 0;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
-}
-lean_ctor_set(x_365, 0, x_339);
-lean_ctor_set(x_365, 1, x_361);
-lean_ctor_set(x_365, 2, x_362);
-lean_ctor_set(x_365, 3, x_340);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-x_366 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_366, 0, x_325);
-lean_ctor_set(x_366, 1, x_326);
-lean_ctor_set(x_366, 2, x_327);
-lean_ctor_set(x_366, 3, x_365);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_348);
-return x_366;
+ x_348 = x_347;
 }
+lean_ctor_set(x_348, 0, x_343);
+lean_ctor_set(x_348, 1, x_43);
+lean_ctor_set(x_348, 2, x_44);
+lean_ctor_set(x_348, 3, x_45);
+lean_ctor_set_uint8(x_348, sizeof(void*)*4, x_345);
+x_349 = 0;
+x_350 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_350, 0, x_346);
+lean_ctor_set(x_350, 1, x_341);
+lean_ctor_set(x_350, 2, x_342);
+lean_ctor_set(x_350, 3, x_348);
+lean_ctor_set_uint8(x_350, sizeof(void*)*4, x_349);
+return x_350;
 }
 }
 else
 {
-uint8_t x_367; 
-x_367 = lean_ctor_get_uint8(x_339, sizeof(void*)*4);
-if (x_367 == 0)
+uint8_t x_351; 
+x_351 = !lean_is_exclusive(x_216);
+if (x_351 == 0)
 {
-lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; uint8_t x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; 
-x_368 = lean_ctor_get(x_338, 1);
+lean_object* x_352; lean_object* x_353; uint8_t x_354; 
+x_352 = lean_ctor_get(x_216, 3);
+lean_dec(x_352);
+x_353 = lean_ctor_get(x_216, 0);
+lean_dec(x_353);
+x_354 = !lean_is_exclusive(x_217);
+if (x_354 == 0)
+{
+uint8_t x_355; uint8_t x_356; 
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_309);
+x_355 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_355);
+x_356 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_356);
+return x_1;
+}
+else
+{
+lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; uint8_t x_363; 
+x_357 = lean_ctor_get(x_217, 0);
+x_358 = lean_ctor_get(x_217, 1);
+x_359 = lean_ctor_get(x_217, 2);
+x_360 = lean_ctor_get(x_217, 3);
+lean_inc(x_360);
+lean_inc(x_359);
+lean_inc(x_358);
+lean_inc(x_357);
+lean_dec(x_217);
+x_361 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_361, 0, x_357);
+lean_ctor_set(x_361, 1, x_358);
+lean_ctor_set(x_361, 2, x_359);
+lean_ctor_set(x_361, 3, x_360);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_309);
+x_362 = 0;
+lean_ctor_set(x_216, 0, x_361);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_362);
+x_363 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_363);
+return x_1;
+}
+}
+else
+{
+lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; uint8_t x_374; 
+x_364 = lean_ctor_get(x_216, 1);
+x_365 = lean_ctor_get(x_216, 2);
+lean_inc(x_365);
+lean_inc(x_364);
+lean_dec(x_216);
+x_366 = lean_ctor_get(x_217, 0);
+lean_inc(x_366);
+x_367 = lean_ctor_get(x_217, 1);
+lean_inc(x_367);
+x_368 = lean_ctor_get(x_217, 2);
 lean_inc(x_368);
-x_369 = lean_ctor_get(x_338, 2);
+x_369 = lean_ctor_get(x_217, 3);
 lean_inc(x_369);
-x_370 = lean_ctor_get(x_338, 3);
-lean_inc(x_370);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_371 = x_338;
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_370 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_371 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_370 = lean_box(0);
 }
-x_372 = lean_ctor_get(x_339, 0);
-lean_inc(x_372);
-x_373 = lean_ctor_get(x_339, 1);
-lean_inc(x_373);
-x_374 = lean_ctor_get(x_339, 2);
-lean_inc(x_374);
-x_375 = lean_ctor_get(x_339, 3);
+if (lean_is_scalar(x_370)) {
+ x_371 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_371 = x_370;
+}
+lean_ctor_set(x_371, 0, x_366);
+lean_ctor_set(x_371, 1, x_367);
+lean_ctor_set(x_371, 2, x_368);
+lean_ctor_set(x_371, 3, x_369);
+lean_ctor_set_uint8(x_371, sizeof(void*)*4, x_309);
+x_372 = 0;
+x_373 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_373, 0, x_371);
+lean_ctor_set(x_373, 1, x_364);
+lean_ctor_set(x_373, 2, x_365);
+lean_ctor_set(x_373, 3, x_298);
+lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
+x_374 = 1;
+lean_ctor_set(x_1, 0, x_373);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_374);
+return x_1;
+}
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; uint32_t x_379; uint8_t x_380; 
+x_375 = lean_ctor_get(x_1, 0);
+x_376 = lean_ctor_get(x_1, 1);
+x_377 = lean_ctor_get(x_1, 2);
+x_378 = lean_ctor_get(x_1, 3);
+lean_inc(x_378);
+lean_inc(x_377);
+lean_inc(x_376);
 lean_inc(x_375);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_376 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_376 = lean_box(0);
-}
-x_377 = 1;
-if (lean_is_scalar(x_376)) {
- x_378 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_378 = x_376;
-}
-lean_ctor_set(x_378, 0, x_325);
-lean_ctor_set(x_378, 1, x_326);
-lean_ctor_set(x_378, 2, x_327);
-lean_ctor_set(x_378, 3, x_372);
-lean_ctor_set_uint8(x_378, sizeof(void*)*4, x_377);
-if (lean_is_scalar(x_371)) {
- x_379 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_379 = x_371;
-}
-lean_ctor_set(x_379, 0, x_375);
-lean_ctor_set(x_379, 1, x_368);
-lean_ctor_set(x_379, 2, x_369);
-lean_ctor_set(x_379, 3, x_370);
-lean_ctor_set_uint8(x_379, sizeof(void*)*4, x_377);
-x_380 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_380, 0, x_378);
-lean_ctor_set(x_380, 1, x_373);
-lean_ctor_set(x_380, 2, x_374);
-lean_ctor_set(x_380, 3, x_379);
-lean_ctor_set_uint8(x_380, sizeof(void*)*4, x_367);
-return x_380;
+lean_dec(x_1);
+x_379 = lean_unbox_uint32(x_376);
+x_380 = x_2 < x_379;
+if (x_380 == 0)
+{
+uint32_t x_381; uint8_t x_382; 
+x_381 = lean_unbox_uint32(x_376);
+x_382 = x_381 < x_2;
+if (x_382 == 0)
+{
+uint8_t x_383; lean_object* x_384; lean_object* x_385; 
+lean_dec(x_377);
+lean_dec(x_376);
+x_383 = 1;
+x_384 = lean_box_uint32(x_2);
+x_385 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_385, 0, x_375);
+lean_ctor_set(x_385, 1, x_384);
+lean_ctor_set(x_385, 2, x_3);
+lean_ctor_set(x_385, 3, x_378);
+lean_ctor_set_uint8(x_385, sizeof(void*)*4, x_383);
+return x_385;
 }
 else
 {
-lean_object* x_381; 
-x_381 = lean_ctor_get(x_338, 3);
-lean_inc(x_381);
-if (lean_obj_tag(x_381) == 0)
+uint8_t x_386; 
+x_386 = l_Std_RBNode_isRed___rarg(x_378);
+if (x_386 == 0)
 {
-lean_object* x_382; lean_object* x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; lean_object* x_387; 
-x_382 = lean_ctor_get(x_338, 1);
-lean_inc(x_382);
-x_383 = lean_ctor_get(x_338, 2);
-lean_inc(x_383);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_384 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_384 = lean_box(0);
-}
-x_385 = 0;
-if (lean_is_scalar(x_384)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_384;
-}
-lean_ctor_set(x_386, 0, x_339);
-lean_ctor_set(x_386, 1, x_382);
-lean_ctor_set(x_386, 2, x_383);
-lean_ctor_set(x_386, 3, x_381);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
-x_387 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_387, 0, x_325);
-lean_ctor_set(x_387, 1, x_326);
-lean_ctor_set(x_387, 2, x_327);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_367);
-return x_387;
+lean_object* x_387; uint8_t x_388; lean_object* x_389; 
+x_387 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_378, x_2, x_3);
+x_388 = 1;
+x_389 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_389, 0, x_375);
+lean_ctor_set(x_389, 1, x_376);
+lean_ctor_set(x_389, 2, x_377);
+lean_ctor_set(x_389, 3, x_387);
+lean_ctor_set_uint8(x_389, sizeof(void*)*4, x_388);
+return x_389;
 }
 else
 {
-uint8_t x_388; 
-x_388 = lean_ctor_get_uint8(x_381, sizeof(void*)*4);
-if (x_388 == 0)
+lean_object* x_390; lean_object* x_391; 
+x_390 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_378, x_2, x_3);
+x_391 = lean_ctor_get(x_390, 0);
+lean_inc(x_391);
+if (lean_obj_tag(x_391) == 0)
 {
-lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; 
-x_389 = lean_ctor_get(x_338, 1);
-lean_inc(x_389);
-x_390 = lean_ctor_get(x_338, 2);
-lean_inc(x_390);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_391 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_391 = lean_box(0);
-}
-x_392 = lean_ctor_get(x_381, 0);
+lean_object* x_392; 
+x_392 = lean_ctor_get(x_390, 3);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_381, 1);
+if (lean_obj_tag(x_392) == 0)
+{
+lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; uint8_t x_398; lean_object* x_399; 
+x_393 = lean_ctor_get(x_390, 1);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_381, 2);
+x_394 = lean_ctor_get(x_390, 2);
 lean_inc(x_394);
-x_395 = lean_ctor_get(x_381, 3);
-lean_inc(x_395);
-if (lean_is_exclusive(x_381)) {
- lean_ctor_release(x_381, 0);
- lean_ctor_release(x_381, 1);
- lean_ctor_release(x_381, 2);
- lean_ctor_release(x_381, 3);
- x_396 = x_381;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_395 = x_390;
 } else {
- lean_dec_ref(x_381);
- x_396 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_395 = lean_box(0);
 }
-lean_inc(x_339);
-if (lean_is_scalar(x_396)) {
+x_396 = 0;
+if (lean_is_scalar(x_395)) {
  x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_397 = x_396;
+ x_397 = x_395;
 }
-lean_ctor_set(x_397, 0, x_325);
-lean_ctor_set(x_397, 1, x_326);
-lean_ctor_set(x_397, 2, x_327);
-lean_ctor_set(x_397, 3, x_339);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_398 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_398 = lean_box(0);
-}
-lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_398)) {
- x_399 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_399 = x_398;
-}
-lean_ctor_set(x_399, 0, x_392);
-lean_ctor_set(x_399, 1, x_393);
-lean_ctor_set(x_399, 2, x_394);
-lean_ctor_set(x_399, 3, x_395);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_391)) {
- x_400 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_400 = x_391;
-}
-lean_ctor_set(x_400, 0, x_397);
-lean_ctor_set(x_400, 1, x_389);
-lean_ctor_set(x_400, 2, x_390);
-lean_ctor_set(x_400, 3, x_399);
-lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_388);
-return x_400;
+lean_ctor_set(x_397, 0, x_392);
+lean_ctor_set(x_397, 1, x_393);
+lean_ctor_set(x_397, 2, x_394);
+lean_ctor_set(x_397, 3, x_392);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
+x_398 = 1;
+x_399 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_399, 0, x_375);
+lean_ctor_set(x_399, 1, x_376);
+lean_ctor_set(x_399, 2, x_377);
+lean_ctor_set(x_399, 3, x_397);
+lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_398);
+return x_399;
 }
 else
 {
-lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; uint8_t x_410; lean_object* x_411; lean_object* x_412; 
-x_401 = lean_ctor_get(x_338, 1);
+uint8_t x_400; 
+x_400 = lean_ctor_get_uint8(x_392, sizeof(void*)*4);
+if (x_400 == 0)
+{
+lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; lean_object* x_411; uint8_t x_412; lean_object* x_413; 
+x_401 = lean_ctor_get(x_390, 1);
 lean_inc(x_401);
-x_402 = lean_ctor_get(x_338, 2);
+x_402 = lean_ctor_get(x_390, 2);
 lean_inc(x_402);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_403 = x_338;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_403 = x_390;
 } else {
- lean_dec_ref(x_338);
+ lean_dec_ref(x_390);
  x_403 = lean_box(0);
 }
-x_404 = lean_ctor_get(x_339, 0);
+x_404 = lean_ctor_get(x_392, 0);
 lean_inc(x_404);
-x_405 = lean_ctor_get(x_339, 1);
+x_405 = lean_ctor_get(x_392, 1);
 lean_inc(x_405);
-x_406 = lean_ctor_get(x_339, 2);
+x_406 = lean_ctor_get(x_392, 2);
 lean_inc(x_406);
-x_407 = lean_ctor_get(x_339, 3);
+x_407 = lean_ctor_get(x_392, 3);
 lean_inc(x_407);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_408 = x_339;
+if (lean_is_exclusive(x_392)) {
+ lean_ctor_release(x_392, 0);
+ lean_ctor_release(x_392, 1);
+ lean_ctor_release(x_392, 2);
+ lean_ctor_release(x_392, 3);
+ x_408 = x_392;
 } else {
- lean_dec_ref(x_339);
+ lean_dec_ref(x_392);
  x_408 = lean_box(0);
 }
+x_409 = 1;
 if (lean_is_scalar(x_408)) {
- x_409 = lean_alloc_ctor(1, 4, 1);
+ x_410 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_409 = x_408;
+ x_410 = x_408;
 }
-lean_ctor_set(x_409, 0, x_404);
-lean_ctor_set(x_409, 1, x_405);
-lean_ctor_set(x_409, 2, x_406);
-lean_ctor_set(x_409, 3, x_407);
-lean_ctor_set_uint8(x_409, sizeof(void*)*4, x_388);
-x_410 = 0;
+lean_ctor_set(x_410, 0, x_375);
+lean_ctor_set(x_410, 1, x_376);
+lean_ctor_set(x_410, 2, x_377);
+lean_ctor_set(x_410, 3, x_391);
+lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
 if (lean_is_scalar(x_403)) {
  x_411 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_411 = x_403;
 }
-lean_ctor_set(x_411, 0, x_409);
-lean_ctor_set(x_411, 1, x_401);
-lean_ctor_set(x_411, 2, x_402);
-lean_ctor_set(x_411, 3, x_381);
-lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_410);
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_325);
-lean_ctor_set(x_412, 1, x_326);
-lean_ctor_set(x_412, 2, x_327);
-lean_ctor_set(x_412, 3, x_411);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_388);
-return x_412;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_411, 0, x_404);
+lean_ctor_set(x_411, 1, x_405);
+lean_ctor_set(x_411, 2, x_406);
+lean_ctor_set(x_411, 3, x_407);
+lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_409);
+x_412 = 0;
+x_413 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_413, 0, x_410);
+lean_ctor_set(x_413, 1, x_401);
+lean_ctor_set(x_413, 2, x_402);
+lean_ctor_set(x_413, 3, x_411);
+lean_ctor_set_uint8(x_413, sizeof(void*)*4, x_412);
+return x_413;
 }
 else
 {
-uint8_t x_413; 
-x_413 = l_Std_RBNode_isRed___rarg(x_325);
-if (x_413 == 0)
-{
-lean_object* x_414; lean_object* x_415; 
-x_414 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_325, x_2, x_3);
-x_415 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_415, 0, x_414);
-lean_ctor_set(x_415, 1, x_326);
-lean_ctor_set(x_415, 2, x_327);
-lean_ctor_set(x_415, 3, x_328);
-lean_ctor_set_uint8(x_415, sizeof(void*)*4, x_7);
-return x_415;
-}
-else
-{
-lean_object* x_416; lean_object* x_417; 
-x_416 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_325, x_2, x_3);
-x_417 = lean_ctor_get(x_416, 0);
-lean_inc(x_417);
-if (lean_obj_tag(x_417) == 0)
-{
-lean_object* x_418; 
-x_418 = lean_ctor_get(x_416, 3);
-lean_inc(x_418);
-if (lean_obj_tag(x_418) == 0)
-{
-lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; uint8_t x_424; lean_object* x_425; 
-x_419 = lean_ctor_get(x_416, 1);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_416, 2);
-lean_inc(x_420);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_421 = x_416;
+lean_object* x_414; lean_object* x_415; lean_object* x_416; uint8_t x_417; lean_object* x_418; uint8_t x_419; lean_object* x_420; 
+x_414 = lean_ctor_get(x_390, 1);
+lean_inc(x_414);
+x_415 = lean_ctor_get(x_390, 2);
+lean_inc(x_415);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_416 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_421 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_416 = lean_box(0);
 }
-x_422 = 0;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+x_417 = 0;
+if (lean_is_scalar(x_416)) {
+ x_418 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_418 = x_416;
+}
+lean_ctor_set(x_418, 0, x_391);
+lean_ctor_set(x_418, 1, x_414);
+lean_ctor_set(x_418, 2, x_415);
+lean_ctor_set(x_418, 3, x_392);
+lean_ctor_set_uint8(x_418, sizeof(void*)*4, x_417);
+x_419 = 1;
+x_420 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_420, 0, x_375);
+lean_ctor_set(x_420, 1, x_376);
+lean_ctor_set(x_420, 2, x_377);
+lean_ctor_set(x_420, 3, x_418);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_419);
+return x_420;
+}
 }
-lean_ctor_set(x_423, 0, x_418);
-lean_ctor_set(x_423, 1, x_419);
-lean_ctor_set(x_423, 2, x_420);
-lean_ctor_set(x_423, 3, x_418);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-x_424 = 1;
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_326);
-lean_ctor_set(x_425, 2, x_327);
-lean_ctor_set(x_425, 3, x_328);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_424);
-return x_425;
 }
 else
 {
-uint8_t x_426; 
-x_426 = lean_ctor_get_uint8(x_418, sizeof(void*)*4);
-if (x_426 == 0)
+uint8_t x_421; 
+x_421 = lean_ctor_get_uint8(x_391, sizeof(void*)*4);
+if (x_421 == 0)
 {
-lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; uint8_t x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; 
-x_427 = lean_ctor_get(x_416, 1);
+lean_object* x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; uint8_t x_431; lean_object* x_432; lean_object* x_433; uint8_t x_434; lean_object* x_435; 
+x_422 = lean_ctor_get(x_390, 1);
+lean_inc(x_422);
+x_423 = lean_ctor_get(x_390, 2);
+lean_inc(x_423);
+x_424 = lean_ctor_get(x_390, 3);
+lean_inc(x_424);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_425 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_425 = lean_box(0);
+}
+x_426 = lean_ctor_get(x_391, 0);
+lean_inc(x_426);
+x_427 = lean_ctor_get(x_391, 1);
 lean_inc(x_427);
-x_428 = lean_ctor_get(x_416, 2);
+x_428 = lean_ctor_get(x_391, 2);
 lean_inc(x_428);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_429 = x_416;
+x_429 = lean_ctor_get(x_391, 3);
+lean_inc(x_429);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_430 = x_391;
 } else {
- lean_dec_ref(x_416);
- x_429 = lean_box(0);
+ lean_dec_ref(x_391);
+ x_430 = lean_box(0);
 }
-x_430 = lean_ctor_get(x_418, 0);
-lean_inc(x_430);
-x_431 = lean_ctor_get(x_418, 1);
-lean_inc(x_431);
-x_432 = lean_ctor_get(x_418, 2);
-lean_inc(x_432);
-x_433 = lean_ctor_get(x_418, 3);
-lean_inc(x_433);
-if (lean_is_exclusive(x_418)) {
- lean_ctor_release(x_418, 0);
- lean_ctor_release(x_418, 1);
- lean_ctor_release(x_418, 2);
- lean_ctor_release(x_418, 3);
- x_434 = x_418;
+x_431 = 1;
+if (lean_is_scalar(x_430)) {
+ x_432 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_418);
- x_434 = lean_box(0);
+ x_432 = x_430;
 }
-x_435 = 1;
-if (lean_is_scalar(x_434)) {
- x_436 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_432, 0, x_375);
+lean_ctor_set(x_432, 1, x_376);
+lean_ctor_set(x_432, 2, x_377);
+lean_ctor_set(x_432, 3, x_426);
+lean_ctor_set_uint8(x_432, sizeof(void*)*4, x_431);
+if (lean_is_scalar(x_425)) {
+ x_433 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_436 = x_434;
+ x_433 = x_425;
 }
-lean_ctor_set(x_436, 0, x_417);
-lean_ctor_set(x_436, 1, x_427);
-lean_ctor_set(x_436, 2, x_428);
-lean_ctor_set(x_436, 3, x_430);
-lean_ctor_set_uint8(x_436, sizeof(void*)*4, x_435);
-if (lean_is_scalar(x_429)) {
- x_437 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_437 = x_429;
-}
-lean_ctor_set(x_437, 0, x_433);
-lean_ctor_set(x_437, 1, x_326);
-lean_ctor_set(x_437, 2, x_327);
-lean_ctor_set(x_437, 3, x_328);
-lean_ctor_set_uint8(x_437, sizeof(void*)*4, x_435);
-x_438 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_438, 0, x_436);
-lean_ctor_set(x_438, 1, x_431);
-lean_ctor_set(x_438, 2, x_432);
-lean_ctor_set(x_438, 3, x_437);
-lean_ctor_set_uint8(x_438, sizeof(void*)*4, x_426);
-return x_438;
+lean_ctor_set(x_433, 0, x_429);
+lean_ctor_set(x_433, 1, x_422);
+lean_ctor_set(x_433, 2, x_423);
+lean_ctor_set(x_433, 3, x_424);
+lean_ctor_set_uint8(x_433, sizeof(void*)*4, x_431);
+x_434 = 0;
+x_435 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_435, 0, x_432);
+lean_ctor_set(x_435, 1, x_427);
+lean_ctor_set(x_435, 2, x_428);
+lean_ctor_set(x_435, 3, x_433);
+lean_ctor_set_uint8(x_435, sizeof(void*)*4, x_434);
+return x_435;
 }
 else
 {
-lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; 
-x_439 = lean_ctor_get(x_416, 1);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_416, 2);
-lean_inc(x_440);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_441 = x_416;
+lean_object* x_436; 
+x_436 = lean_ctor_get(x_390, 3);
+lean_inc(x_436);
+if (lean_obj_tag(x_436) == 0)
+{
+lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; 
+x_437 = lean_ctor_get(x_390, 1);
+lean_inc(x_437);
+x_438 = lean_ctor_get(x_390, 2);
+lean_inc(x_438);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_439 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_441 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_439 = lean_box(0);
 }
-x_442 = 0;
-if (lean_is_scalar(x_441)) {
- x_443 = lean_alloc_ctor(1, 4, 1);
+x_440 = 0;
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_441 = x_439;
 }
-lean_ctor_set(x_443, 0, x_417);
-lean_ctor_set(x_443, 1, x_439);
-lean_ctor_set(x_443, 2, x_440);
-lean_ctor_set(x_443, 3, x_418);
+lean_ctor_set(x_441, 0, x_391);
+lean_ctor_set(x_441, 1, x_437);
+lean_ctor_set(x_441, 2, x_438);
+lean_ctor_set(x_441, 3, x_436);
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+x_442 = 1;
+x_443 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_375);
+lean_ctor_set(x_443, 1, x_376);
+lean_ctor_set(x_443, 2, x_377);
+lean_ctor_set(x_443, 3, x_441);
 lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-x_444 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_444, 0, x_443);
-lean_ctor_set(x_444, 1, x_326);
-lean_ctor_set(x_444, 2, x_327);
-lean_ctor_set(x_444, 3, x_328);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_426);
-return x_444;
-}
-}
+return x_443;
 }
 else
 {
-uint8_t x_445; 
-x_445 = lean_ctor_get_uint8(x_417, sizeof(void*)*4);
-if (x_445 == 0)
+uint8_t x_444; 
+x_444 = lean_ctor_get_uint8(x_436, sizeof(void*)*4);
+if (x_444 == 0)
 {
-lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; 
-x_446 = lean_ctor_get(x_416, 1);
+lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; uint8_t x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_445 = lean_ctor_get(x_390, 1);
+lean_inc(x_445);
+x_446 = lean_ctor_get(x_390, 2);
 lean_inc(x_446);
-x_447 = lean_ctor_get(x_416, 2);
-lean_inc(x_447);
-x_448 = lean_ctor_get(x_416, 3);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_447 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_447 = lean_box(0);
+}
+x_448 = lean_ctor_get(x_436, 0);
 lean_inc(x_448);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_449 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_449 = lean_box(0);
-}
-x_450 = lean_ctor_get(x_417, 0);
+x_449 = lean_ctor_get(x_436, 1);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_436, 2);
 lean_inc(x_450);
-x_451 = lean_ctor_get(x_417, 1);
+x_451 = lean_ctor_get(x_436, 3);
 lean_inc(x_451);
-x_452 = lean_ctor_get(x_417, 2);
-lean_inc(x_452);
-x_453 = lean_ctor_get(x_417, 3);
-lean_inc(x_453);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_454 = x_417;
+if (lean_is_exclusive(x_436)) {
+ lean_ctor_release(x_436, 0);
+ lean_ctor_release(x_436, 1);
+ lean_ctor_release(x_436, 2);
+ lean_ctor_release(x_436, 3);
+ x_452 = x_436;
 } else {
- lean_dec_ref(x_417);
- x_454 = lean_box(0);
+ lean_dec_ref(x_436);
+ x_452 = lean_box(0);
 }
-x_455 = 1;
-if (lean_is_scalar(x_454)) {
+x_453 = 1;
+lean_inc(x_391);
+if (lean_is_scalar(x_452)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_452;
+}
+lean_ctor_set(x_454, 0, x_375);
+lean_ctor_set(x_454, 1, x_376);
+lean_ctor_set(x_454, 2, x_377);
+lean_ctor_set(x_454, 3, x_391);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_455 = x_391;
+} else {
+ lean_dec_ref(x_391);
+ x_455 = lean_box(0);
+}
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_453);
+if (lean_is_scalar(x_455)) {
  x_456 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_456 = x_454;
+ x_456 = x_455;
 }
-lean_ctor_set(x_456, 0, x_450);
-lean_ctor_set(x_456, 1, x_451);
-lean_ctor_set(x_456, 2, x_452);
-lean_ctor_set(x_456, 3, x_453);
-lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
-if (lean_is_scalar(x_449)) {
- x_457 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_456, 0, x_448);
+lean_ctor_set(x_456, 1, x_449);
+lean_ctor_set(x_456, 2, x_450);
+lean_ctor_set(x_456, 3, x_451);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_453);
+x_457 = 0;
+if (lean_is_scalar(x_447)) {
+ x_458 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_457 = x_449;
+ x_458 = x_447;
 }
-lean_ctor_set(x_457, 0, x_448);
-lean_ctor_set(x_457, 1, x_326);
-lean_ctor_set(x_457, 2, x_327);
-lean_ctor_set(x_457, 3, x_328);
-lean_ctor_set_uint8(x_457, sizeof(void*)*4, x_455);
-x_458 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_458, 0, x_456);
-lean_ctor_set(x_458, 1, x_446);
-lean_ctor_set(x_458, 2, x_447);
-lean_ctor_set(x_458, 3, x_457);
-lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_445);
+lean_ctor_set(x_458, 0, x_454);
+lean_ctor_set(x_458, 1, x_445);
+lean_ctor_set(x_458, 2, x_446);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
 return x_458;
 }
 else
 {
-lean_object* x_459; 
-x_459 = lean_ctor_get(x_416, 3);
+lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; uint8_t x_468; lean_object* x_469; uint8_t x_470; lean_object* x_471; 
+x_459 = lean_ctor_get(x_390, 1);
 lean_inc(x_459);
-if (lean_obj_tag(x_459) == 0)
-{
-lean_object* x_460; lean_object* x_461; lean_object* x_462; uint8_t x_463; lean_object* x_464; lean_object* x_465; 
-x_460 = lean_ctor_get(x_416, 1);
+x_460 = lean_ctor_get(x_390, 2);
 lean_inc(x_460);
-x_461 = lean_ctor_get(x_416, 2);
-lean_inc(x_461);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_462 = x_416;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_461 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_462 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_461 = lean_box(0);
 }
-x_463 = 0;
-if (lean_is_scalar(x_462)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
+x_462 = lean_ctor_get(x_391, 0);
+lean_inc(x_462);
+x_463 = lean_ctor_get(x_391, 1);
+lean_inc(x_463);
+x_464 = lean_ctor_get(x_391, 2);
+lean_inc(x_464);
+x_465 = lean_ctor_get(x_391, 3);
+lean_inc(x_465);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_466 = x_391;
 } else {
- x_464 = x_462;
+ lean_dec_ref(x_391);
+ x_466 = lean_box(0);
+}
+if (lean_is_scalar(x_466)) {
+ x_467 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_467 = x_466;
+}
+lean_ctor_set(x_467, 0, x_462);
+lean_ctor_set(x_467, 1, x_463);
+lean_ctor_set(x_467, 2, x_464);
+lean_ctor_set(x_467, 3, x_465);
+lean_ctor_set_uint8(x_467, sizeof(void*)*4, x_444);
+x_468 = 0;
+if (lean_is_scalar(x_461)) {
+ x_469 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_469 = x_461;
+}
+lean_ctor_set(x_469, 0, x_467);
+lean_ctor_set(x_469, 1, x_459);
+lean_ctor_set(x_469, 2, x_460);
+lean_ctor_set(x_469, 3, x_436);
+lean_ctor_set_uint8(x_469, sizeof(void*)*4, x_468);
+x_470 = 1;
+x_471 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_471, 0, x_375);
+lean_ctor_set(x_471, 1, x_376);
+lean_ctor_set(x_471, 2, x_377);
+lean_ctor_set(x_471, 3, x_469);
+lean_ctor_set_uint8(x_471, sizeof(void*)*4, x_470);
+return x_471;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_464, 0, x_417);
-lean_ctor_set(x_464, 1, x_460);
-lean_ctor_set(x_464, 2, x_461);
-lean_ctor_set(x_464, 3, x_459);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_463);
-x_465 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_465, 0, x_464);
-lean_ctor_set(x_465, 1, x_326);
-lean_ctor_set(x_465, 2, x_327);
-lean_ctor_set(x_465, 3, x_328);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_445);
-return x_465;
 }
 else
 {
-uint8_t x_466; 
-x_466 = lean_ctor_get_uint8(x_459, sizeof(void*)*4);
-if (x_466 == 0)
+uint8_t x_472; 
+x_472 = l_Std_RBNode_isRed___rarg(x_375);
+if (x_472 == 0)
 {
-lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; 
-x_467 = lean_ctor_get(x_416, 1);
-lean_inc(x_467);
-x_468 = lean_ctor_get(x_416, 2);
-lean_inc(x_468);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_469 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_469 = lean_box(0);
-}
-x_470 = lean_ctor_get(x_459, 0);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_459, 1);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_459, 2);
-lean_inc(x_472);
-x_473 = lean_ctor_get(x_459, 3);
-lean_inc(x_473);
-if (lean_is_exclusive(x_459)) {
- lean_ctor_release(x_459, 0);
- lean_ctor_release(x_459, 1);
- lean_ctor_release(x_459, 2);
- lean_ctor_release(x_459, 3);
- x_474 = x_459;
-} else {
- lean_dec_ref(x_459);
- x_474 = lean_box(0);
-}
-lean_inc(x_417);
-if (lean_is_scalar(x_474)) {
- x_475 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_475 = x_474;
-}
-lean_ctor_set(x_475, 0, x_417);
-lean_ctor_set(x_475, 1, x_467);
-lean_ctor_set(x_475, 2, x_468);
-lean_ctor_set(x_475, 3, x_470);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_476 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_476 = lean_box(0);
-}
-lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_476)) {
- x_477 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_477 = x_476;
-}
-lean_ctor_set(x_477, 0, x_473);
-lean_ctor_set(x_477, 1, x_326);
-lean_ctor_set(x_477, 2, x_327);
-lean_ctor_set(x_477, 3, x_328);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_469)) {
- x_478 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_478 = x_469;
-}
-lean_ctor_set(x_478, 0, x_475);
-lean_ctor_set(x_478, 1, x_471);
-lean_ctor_set(x_478, 2, x_472);
-lean_ctor_set(x_478, 3, x_477);
-lean_ctor_set_uint8(x_478, sizeof(void*)*4, x_466);
-return x_478;
+lean_object* x_473; uint8_t x_474; lean_object* x_475; 
+x_473 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_375, x_2, x_3);
+x_474 = 1;
+x_475 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_475, 0, x_473);
+lean_ctor_set(x_475, 1, x_376);
+lean_ctor_set(x_475, 2, x_377);
+lean_ctor_set(x_475, 3, x_378);
+lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_474);
+return x_475;
 }
 else
 {
-lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; uint8_t x_488; lean_object* x_489; lean_object* x_490; 
-x_479 = lean_ctor_get(x_416, 1);
+lean_object* x_476; lean_object* x_477; 
+x_476 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_375, x_2, x_3);
+x_477 = lean_ctor_get(x_476, 0);
+lean_inc(x_477);
+if (lean_obj_tag(x_477) == 0)
+{
+lean_object* x_478; 
+x_478 = lean_ctor_get(x_476, 3);
+lean_inc(x_478);
+if (lean_obj_tag(x_478) == 0)
+{
+lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; uint8_t x_484; lean_object* x_485; 
+x_479 = lean_ctor_get(x_476, 1);
 lean_inc(x_479);
-x_480 = lean_ctor_get(x_416, 2);
+x_480 = lean_ctor_get(x_476, 2);
 lean_inc(x_480);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_481 = x_416;
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_481 = x_476;
 } else {
- lean_dec_ref(x_416);
+ lean_dec_ref(x_476);
  x_481 = lean_box(0);
 }
-x_482 = lean_ctor_get(x_417, 0);
-lean_inc(x_482);
-x_483 = lean_ctor_get(x_417, 1);
-lean_inc(x_483);
-x_484 = lean_ctor_get(x_417, 2);
-lean_inc(x_484);
-x_485 = lean_ctor_get(x_417, 3);
-lean_inc(x_485);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_486 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_486 = lean_box(0);
-}
-if (lean_is_scalar(x_486)) {
- x_487 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_487 = x_486;
-}
-lean_ctor_set(x_487, 0, x_482);
-lean_ctor_set(x_487, 1, x_483);
-lean_ctor_set(x_487, 2, x_484);
-lean_ctor_set(x_487, 3, x_485);
-lean_ctor_set_uint8(x_487, sizeof(void*)*4, x_466);
-x_488 = 0;
+x_482 = 0;
 if (lean_is_scalar(x_481)) {
- x_489 = lean_alloc_ctor(1, 4, 1);
+ x_483 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_489 = x_481;
+ x_483 = x_481;
 }
-lean_ctor_set(x_489, 0, x_487);
-lean_ctor_set(x_489, 1, x_479);
-lean_ctor_set(x_489, 2, x_480);
-lean_ctor_set(x_489, 3, x_459);
-lean_ctor_set_uint8(x_489, sizeof(void*)*4, x_488);
-x_490 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_490, 0, x_489);
-lean_ctor_set(x_490, 1, x_326);
-lean_ctor_set(x_490, 2, x_327);
-lean_ctor_set(x_490, 3, x_328);
-lean_ctor_set_uint8(x_490, sizeof(void*)*4, x_466);
-return x_490;
+lean_ctor_set(x_483, 0, x_478);
+lean_ctor_set(x_483, 1, x_479);
+lean_ctor_set(x_483, 2, x_480);
+lean_ctor_set(x_483, 3, x_478);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+x_484 = 1;
+x_485 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_485, 0, x_483);
+lean_ctor_set(x_485, 1, x_376);
+lean_ctor_set(x_485, 2, x_377);
+lean_ctor_set(x_485, 3, x_378);
+lean_ctor_set_uint8(x_485, sizeof(void*)*4, x_484);
+return x_485;
+}
+else
+{
+uint8_t x_486; 
+x_486 = lean_ctor_get_uint8(x_478, sizeof(void*)*4);
+if (x_486 == 0)
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; uint8_t x_495; lean_object* x_496; lean_object* x_497; uint8_t x_498; lean_object* x_499; 
+x_487 = lean_ctor_get(x_476, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_476, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_489 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_489 = lean_box(0);
+}
+x_490 = lean_ctor_get(x_478, 0);
+lean_inc(x_490);
+x_491 = lean_ctor_get(x_478, 1);
+lean_inc(x_491);
+x_492 = lean_ctor_get(x_478, 2);
+lean_inc(x_492);
+x_493 = lean_ctor_get(x_478, 3);
+lean_inc(x_493);
+if (lean_is_exclusive(x_478)) {
+ lean_ctor_release(x_478, 0);
+ lean_ctor_release(x_478, 1);
+ lean_ctor_release(x_478, 2);
+ lean_ctor_release(x_478, 3);
+ x_494 = x_478;
+} else {
+ lean_dec_ref(x_478);
+ x_494 = lean_box(0);
+}
+x_495 = 1;
+if (lean_is_scalar(x_494)) {
+ x_496 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_496 = x_494;
+}
+lean_ctor_set(x_496, 0, x_477);
+lean_ctor_set(x_496, 1, x_487);
+lean_ctor_set(x_496, 2, x_488);
+lean_ctor_set(x_496, 3, x_490);
+lean_ctor_set_uint8(x_496, sizeof(void*)*4, x_495);
+if (lean_is_scalar(x_489)) {
+ x_497 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_497 = x_489;
+}
+lean_ctor_set(x_497, 0, x_493);
+lean_ctor_set(x_497, 1, x_376);
+lean_ctor_set(x_497, 2, x_377);
+lean_ctor_set(x_497, 3, x_378);
+lean_ctor_set_uint8(x_497, sizeof(void*)*4, x_495);
+x_498 = 0;
+x_499 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_499, 0, x_496);
+lean_ctor_set(x_499, 1, x_491);
+lean_ctor_set(x_499, 2, x_492);
+lean_ctor_set(x_499, 3, x_497);
+lean_ctor_set_uint8(x_499, sizeof(void*)*4, x_498);
+return x_499;
+}
+else
+{
+lean_object* x_500; lean_object* x_501; lean_object* x_502; uint8_t x_503; lean_object* x_504; uint8_t x_505; lean_object* x_506; 
+x_500 = lean_ctor_get(x_476, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_476, 2);
+lean_inc(x_501);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_502 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_502 = lean_box(0);
+}
+x_503 = 0;
+if (lean_is_scalar(x_502)) {
+ x_504 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_504 = x_502;
+}
+lean_ctor_set(x_504, 0, x_477);
+lean_ctor_set(x_504, 1, x_500);
+lean_ctor_set(x_504, 2, x_501);
+lean_ctor_set(x_504, 3, x_478);
+lean_ctor_set_uint8(x_504, sizeof(void*)*4, x_503);
+x_505 = 1;
+x_506 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_506, 0, x_504);
+lean_ctor_set(x_506, 1, x_376);
+lean_ctor_set(x_506, 2, x_377);
+lean_ctor_set(x_506, 3, x_378);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_505);
+return x_506;
+}
+}
+}
+else
+{
+uint8_t x_507; 
+x_507 = lean_ctor_get_uint8(x_477, sizeof(void*)*4);
+if (x_507 == 0)
+{
+lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; lean_object* x_516; uint8_t x_517; lean_object* x_518; lean_object* x_519; uint8_t x_520; lean_object* x_521; 
+x_508 = lean_ctor_get(x_476, 1);
+lean_inc(x_508);
+x_509 = lean_ctor_get(x_476, 2);
+lean_inc(x_509);
+x_510 = lean_ctor_get(x_476, 3);
+lean_inc(x_510);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_511 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_511 = lean_box(0);
+}
+x_512 = lean_ctor_get(x_477, 0);
+lean_inc(x_512);
+x_513 = lean_ctor_get(x_477, 1);
+lean_inc(x_513);
+x_514 = lean_ctor_get(x_477, 2);
+lean_inc(x_514);
+x_515 = lean_ctor_get(x_477, 3);
+lean_inc(x_515);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_516 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_516 = lean_box(0);
+}
+x_517 = 1;
+if (lean_is_scalar(x_516)) {
+ x_518 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_518 = x_516;
+}
+lean_ctor_set(x_518, 0, x_512);
+lean_ctor_set(x_518, 1, x_513);
+lean_ctor_set(x_518, 2, x_514);
+lean_ctor_set(x_518, 3, x_515);
+lean_ctor_set_uint8(x_518, sizeof(void*)*4, x_517);
+if (lean_is_scalar(x_511)) {
+ x_519 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_519 = x_511;
+}
+lean_ctor_set(x_519, 0, x_510);
+lean_ctor_set(x_519, 1, x_376);
+lean_ctor_set(x_519, 2, x_377);
+lean_ctor_set(x_519, 3, x_378);
+lean_ctor_set_uint8(x_519, sizeof(void*)*4, x_517);
+x_520 = 0;
+x_521 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_521, 0, x_518);
+lean_ctor_set(x_521, 1, x_508);
+lean_ctor_set(x_521, 2, x_509);
+lean_ctor_set(x_521, 3, x_519);
+lean_ctor_set_uint8(x_521, sizeof(void*)*4, x_520);
+return x_521;
+}
+else
+{
+lean_object* x_522; 
+x_522 = lean_ctor_get(x_476, 3);
+lean_inc(x_522);
+if (lean_obj_tag(x_522) == 0)
+{
+lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; uint8_t x_528; lean_object* x_529; 
+x_523 = lean_ctor_get(x_476, 1);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_476, 2);
+lean_inc(x_524);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_525 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_525 = lean_box(0);
+}
+x_526 = 0;
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_477);
+lean_ctor_set(x_527, 1, x_523);
+lean_ctor_set(x_527, 2, x_524);
+lean_ctor_set(x_527, 3, x_522);
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+x_528 = 1;
+x_529 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_529, 0, x_527);
+lean_ctor_set(x_529, 1, x_376);
+lean_ctor_set(x_529, 2, x_377);
+lean_ctor_set(x_529, 3, x_378);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_528);
+return x_529;
+}
+else
+{
+uint8_t x_530; 
+x_530 = lean_ctor_get_uint8(x_522, sizeof(void*)*4);
+if (x_530 == 0)
+{
+lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; uint8_t x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_531 = lean_ctor_get(x_476, 1);
+lean_inc(x_531);
+x_532 = lean_ctor_get(x_476, 2);
+lean_inc(x_532);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_533 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_533 = lean_box(0);
+}
+x_534 = lean_ctor_get(x_522, 0);
+lean_inc(x_534);
+x_535 = lean_ctor_get(x_522, 1);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_522, 2);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_522, 3);
+lean_inc(x_537);
+if (lean_is_exclusive(x_522)) {
+ lean_ctor_release(x_522, 0);
+ lean_ctor_release(x_522, 1);
+ lean_ctor_release(x_522, 2);
+ lean_ctor_release(x_522, 3);
+ x_538 = x_522;
+} else {
+ lean_dec_ref(x_522);
+ x_538 = lean_box(0);
+}
+x_539 = 1;
+lean_inc(x_477);
+if (lean_is_scalar(x_538)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_538;
+}
+lean_ctor_set(x_540, 0, x_477);
+lean_ctor_set(x_540, 1, x_531);
+lean_ctor_set(x_540, 2, x_532);
+lean_ctor_set(x_540, 3, x_534);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_541 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_541 = lean_box(0);
+}
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_539);
+if (lean_is_scalar(x_541)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_541;
+}
+lean_ctor_set(x_542, 0, x_537);
+lean_ctor_set(x_542, 1, x_376);
+lean_ctor_set(x_542, 2, x_377);
+lean_ctor_set(x_542, 3, x_378);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_539);
+x_543 = 0;
+if (lean_is_scalar(x_533)) {
+ x_544 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_544 = x_533;
+}
+lean_ctor_set(x_544, 0, x_540);
+lean_ctor_set(x_544, 1, x_535);
+lean_ctor_set(x_544, 2, x_536);
+lean_ctor_set(x_544, 3, x_542);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
+}
+else
+{
+lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; uint8_t x_554; lean_object* x_555; uint8_t x_556; lean_object* x_557; 
+x_545 = lean_ctor_get(x_476, 1);
+lean_inc(x_545);
+x_546 = lean_ctor_get(x_476, 2);
+lean_inc(x_546);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_547 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_547 = lean_box(0);
+}
+x_548 = lean_ctor_get(x_477, 0);
+lean_inc(x_548);
+x_549 = lean_ctor_get(x_477, 1);
+lean_inc(x_549);
+x_550 = lean_ctor_get(x_477, 2);
+lean_inc(x_550);
+x_551 = lean_ctor_get(x_477, 3);
+lean_inc(x_551);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_552 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_552 = lean_box(0);
+}
+if (lean_is_scalar(x_552)) {
+ x_553 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_553 = x_552;
+}
+lean_ctor_set(x_553, 0, x_548);
+lean_ctor_set(x_553, 1, x_549);
+lean_ctor_set(x_553, 2, x_550);
+lean_ctor_set(x_553, 3, x_551);
+lean_ctor_set_uint8(x_553, sizeof(void*)*4, x_530);
+x_554 = 0;
+if (lean_is_scalar(x_547)) {
+ x_555 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_555 = x_547;
+}
+lean_ctor_set(x_555, 0, x_553);
+lean_ctor_set(x_555, 1, x_545);
+lean_ctor_set(x_555, 2, x_546);
+lean_ctor_set(x_555, 3, x_522);
+lean_ctor_set_uint8(x_555, sizeof(void*)*4, x_554);
+x_556 = 1;
+x_557 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_557, 0, x_555);
+lean_ctor_set(x_557, 1, x_376);
+lean_ctor_set(x_557, 2, x_377);
+lean_ctor_set(x_557, 3, x_378);
+lean_ctor_set_uint8(x_557, sizeof(void*)*4, x_556);
+return x_557;
 }
 }
 }
@@ -5096,15 +5365,15 @@ return x_490;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
 _start:
 {
 uint8_t x_4; 
@@ -5112,2415 +5381,2490 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
 }
 }
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2(lean_object* x_1) {
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; lean_object* x_6; 
-x_4 = 0;
-x_5 = lean_box_uint32(x_2);
-x_6 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_6, 0, x_1);
-lean_ctor_set(x_6, 1, x_5);
-lean_ctor_set(x_6, 2, x_3);
-lean_ctor_set(x_6, 3, x_1);
-lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_4);
-return x_6;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_box_uint32(x_2);
+x_7 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 2, x_3);
+lean_ctor_set(x_7, 3, x_4);
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_5);
+return x_7;
 }
 else
 {
-uint8_t x_7; 
-x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_7 == 0)
-{
 uint8_t x_8; 
-x_8 = !lean_is_exclusive(x_1);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_8 == 0)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint32_t x_13; uint8_t x_14; 
-x_9 = lean_ctor_get(x_1, 0);
-x_10 = lean_ctor_get(x_1, 1);
-x_11 = lean_ctor_get(x_1, 2);
-x_12 = lean_ctor_get(x_1, 3);
-x_13 = lean_unbox_uint32(x_10);
-x_14 = x_2 < x_13;
-if (x_14 == 0)
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_1);
+if (x_9 == 0)
 {
-uint32_t x_15; uint8_t x_16; 
-x_15 = lean_unbox_uint32(x_10);
-x_16 = x_15 < x_2;
-if (x_16 == 0)
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint32_t x_14; uint8_t x_15; 
+x_10 = lean_ctor_get(x_1, 0);
+x_11 = lean_ctor_get(x_1, 1);
+x_12 = lean_ctor_get(x_1, 2);
+x_13 = lean_ctor_get(x_1, 3);
+x_14 = lean_unbox_uint32(x_11);
+x_15 = x_2 < x_14;
+if (x_15 == 0)
 {
-lean_object* x_17; 
+uint32_t x_16; uint8_t x_17; 
+x_16 = lean_unbox_uint32(x_11);
+x_17 = x_16 < x_2;
+if (x_17 == 0)
+{
+uint8_t x_18; lean_object* x_19; 
+lean_dec(x_12);
 lean_dec(x_11);
-lean_dec(x_10);
-x_17 = lean_box_uint32(x_2);
+x_18 = 0;
+x_19 = lean_box_uint32(x_2);
 lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_17);
+lean_ctor_set(x_1, 1, x_19);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_18);
 return x_1;
 }
 else
 {
-lean_object* x_18; 
-x_18 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_12, x_2, x_3);
-lean_ctor_set(x_1, 3, x_18);
+lean_object* x_20; uint8_t x_21; 
+x_20 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_13, x_2, x_3);
+x_21 = 0;
+lean_ctor_set(x_1, 3, x_20);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_21);
 return x_1;
 }
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_9, x_2, x_3);
-lean_ctor_set(x_1, 0, x_19);
+lean_object* x_22; uint8_t x_23; 
+x_22 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_10, x_2, x_3);
+x_23 = 0;
+lean_ctor_set(x_1, 0, x_22);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_23);
 return x_1;
 }
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint32_t x_24; uint8_t x_25; 
-x_20 = lean_ctor_get(x_1, 0);
-x_21 = lean_ctor_get(x_1, 1);
-x_22 = lean_ctor_get(x_1, 2);
-x_23 = lean_ctor_get(x_1, 3);
-lean_inc(x_23);
-lean_inc(x_22);
-lean_inc(x_21);
-lean_inc(x_20);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint32_t x_28; uint8_t x_29; 
+x_24 = lean_ctor_get(x_1, 0);
+x_25 = lean_ctor_get(x_1, 1);
+x_26 = lean_ctor_get(x_1, 2);
+x_27 = lean_ctor_get(x_1, 3);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_inc(x_24);
 lean_dec(x_1);
-x_24 = lean_unbox_uint32(x_21);
-x_25 = x_2 < x_24;
-if (x_25 == 0)
+x_28 = lean_unbox_uint32(x_25);
+x_29 = x_2 < x_28;
+if (x_29 == 0)
 {
-uint32_t x_26; uint8_t x_27; 
-x_26 = lean_unbox_uint32(x_21);
-x_27 = x_26 < x_2;
-if (x_27 == 0)
+uint32_t x_30; uint8_t x_31; 
+x_30 = lean_unbox_uint32(x_25);
+x_31 = x_30 < x_2;
+if (x_31 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_21);
-x_28 = lean_box_uint32(x_2);
-x_29 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_29, 0, x_20);
-lean_ctor_set(x_29, 1, x_28);
-lean_ctor_set(x_29, 2, x_3);
-lean_ctor_set(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, sizeof(void*)*4, x_7);
-return x_29;
+uint8_t x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_26);
+lean_dec(x_25);
+x_32 = 0;
+x_33 = lean_box_uint32(x_2);
+x_34 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_34, 0, x_24);
+lean_ctor_set(x_34, 1, x_33);
+lean_ctor_set(x_34, 2, x_3);
+lean_ctor_set(x_34, 3, x_27);
+lean_ctor_set_uint8(x_34, sizeof(void*)*4, x_32);
+return x_34;
 }
 else
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_23, x_2, x_3);
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_20);
-lean_ctor_set(x_31, 1, x_21);
-lean_ctor_set(x_31, 2, x_22);
-lean_ctor_set(x_31, 3, x_30);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_7);
-return x_31;
+lean_object* x_35; uint8_t x_36; lean_object* x_37; 
+x_35 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_27, x_2, x_3);
+x_36 = 0;
+x_37 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_37, 0, x_24);
+lean_ctor_set(x_37, 1, x_25);
+lean_ctor_set(x_37, 2, x_26);
+lean_ctor_set(x_37, 3, x_35);
+lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
+return x_37;
 }
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_20, x_2, x_3);
-x_33 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_21);
-lean_ctor_set(x_33, 2, x_22);
-lean_ctor_set(x_33, 3, x_23);
-lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_7);
-return x_33;
+lean_object* x_38; uint8_t x_39; lean_object* x_40; 
+x_38 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_24, x_2, x_3);
+x_39 = 0;
+x_40 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_25);
+lean_ctor_set(x_40, 2, x_26);
+lean_ctor_set(x_40, 3, x_27);
+lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = !lean_is_exclusive(x_1);
-if (x_34 == 0)
+uint8_t x_41; 
+x_41 = !lean_is_exclusive(x_1);
+if (x_41 == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint32_t x_39; uint8_t x_40; 
-x_35 = lean_ctor_get(x_1, 0);
-x_36 = lean_ctor_get(x_1, 1);
-x_37 = lean_ctor_get(x_1, 2);
-x_38 = lean_ctor_get(x_1, 3);
-x_39 = lean_unbox_uint32(x_36);
-x_40 = x_2 < x_39;
-if (x_40 == 0)
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint32_t x_46; uint8_t x_47; 
+x_42 = lean_ctor_get(x_1, 0);
+x_43 = lean_ctor_get(x_1, 1);
+x_44 = lean_ctor_get(x_1, 2);
+x_45 = lean_ctor_get(x_1, 3);
+x_46 = lean_unbox_uint32(x_43);
+x_47 = x_2 < x_46;
+if (x_47 == 0)
 {
-uint32_t x_41; uint8_t x_42; 
-x_41 = lean_unbox_uint32(x_36);
-x_42 = x_41 < x_2;
-if (x_42 == 0)
-{
-lean_object* x_43; 
-lean_dec(x_37);
-lean_dec(x_36);
-x_43 = lean_box_uint32(x_2);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_43);
-return x_1;
-}
-else
-{
-uint8_t x_44; 
-x_44 = l_Std_RBNode_isRed___rarg(x_38);
-if (x_44 == 0)
-{
-lean_object* x_45; 
-x_45 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_38, x_2, x_3);
-lean_ctor_set(x_1, 3, x_45);
-return x_1;
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-x_46 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_38, x_2, x_3);
-x_47 = lean_ctor_get(x_46, 0);
-lean_inc(x_47);
-if (lean_obj_tag(x_47) == 0)
-{
-lean_object* x_48; 
-x_48 = lean_ctor_get(x_46, 3);
-lean_inc(x_48);
-if (lean_obj_tag(x_48) == 0)
-{
-uint8_t x_49; 
-x_49 = !lean_is_exclusive(x_46);
+uint32_t x_48; uint8_t x_49; 
+x_48 = lean_unbox_uint32(x_43);
+x_49 = x_48 < x_2;
 if (x_49 == 0)
 {
-lean_object* x_50; lean_object* x_51; uint8_t x_52; uint8_t x_53; 
-x_50 = lean_ctor_get(x_46, 3);
-lean_dec(x_50);
-x_51 = lean_ctor_get(x_46, 0);
-lean_dec(x_51);
-x_52 = 0;
-lean_ctor_set(x_46, 0, x_48);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_52);
-x_53 = 1;
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_53);
+uint8_t x_50; lean_object* x_51; 
+lean_dec(x_44);
+lean_dec(x_43);
+x_50 = 1;
+x_51 = lean_box_uint32(x_2);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_51);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_50);
 return x_1;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; 
-x_54 = lean_ctor_get(x_46, 1);
-x_55 = lean_ctor_get(x_46, 2);
-lean_inc(x_55);
-lean_inc(x_54);
-lean_dec(x_46);
-x_56 = 0;
-x_57 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_57, 0, x_48);
-lean_ctor_set(x_57, 1, x_54);
-lean_ctor_set(x_57, 2, x_55);
-lean_ctor_set(x_57, 3, x_48);
-lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_56);
-x_58 = 1;
-lean_ctor_set(x_1, 3, x_57);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_58);
+uint8_t x_52; 
+x_52 = l_Std_RBNode_isRed___rarg(x_45);
+if (x_52 == 0)
+{
+lean_object* x_53; uint8_t x_54; 
+x_53 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_45, x_2, x_3);
+x_54 = 1;
+lean_ctor_set(x_1, 3, x_53);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_54);
+return x_1;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_45, x_2, x_3);
+x_56 = lean_ctor_get(x_55, 0);
+lean_inc(x_56);
+if (lean_obj_tag(x_56) == 0)
+{
+lean_object* x_57; 
+x_57 = lean_ctor_get(x_55, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
+{
+uint8_t x_58; 
+x_58 = !lean_is_exclusive(x_55);
+if (x_58 == 0)
+{
+lean_object* x_59; lean_object* x_60; uint8_t x_61; uint8_t x_62; 
+x_59 = lean_ctor_get(x_55, 3);
+lean_dec(x_59);
+x_60 = lean_ctor_get(x_55, 0);
+lean_dec(x_60);
+x_61 = 0;
+lean_ctor_set(x_55, 0, x_57);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_61);
+x_62 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_62);
+return x_1;
+}
+else
+{
+lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; uint8_t x_67; 
+x_63 = lean_ctor_get(x_55, 1);
+x_64 = lean_ctor_get(x_55, 2);
+lean_inc(x_64);
+lean_inc(x_63);
+lean_dec(x_55);
+x_65 = 0;
+x_66 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_66, 0, x_57);
+lean_ctor_set(x_66, 1, x_63);
+lean_ctor_set(x_66, 2, x_64);
+lean_ctor_set(x_66, 3, x_57);
+lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
+x_67 = 1;
+lean_ctor_set(x_1, 3, x_66);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_67);
 return x_1;
 }
 }
 else
 {
-uint8_t x_59; 
-x_59 = lean_ctor_get_uint8(x_48, sizeof(void*)*4);
-if (x_59 == 0)
+uint8_t x_68; 
+x_68 = lean_ctor_get_uint8(x_57, sizeof(void*)*4);
+if (x_68 == 0)
 {
-uint8_t x_60; 
-x_60 = !lean_is_exclusive(x_46);
-if (x_60 == 0)
+uint8_t x_69; 
+x_69 = !lean_is_exclusive(x_55);
+if (x_69 == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; 
-x_61 = lean_ctor_get(x_46, 1);
-x_62 = lean_ctor_get(x_46, 2);
-x_63 = lean_ctor_get(x_46, 3);
-lean_dec(x_63);
-x_64 = lean_ctor_get(x_46, 0);
-lean_dec(x_64);
-x_65 = !lean_is_exclusive(x_48);
-if (x_65 == 0)
+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_55, 1);
+x_71 = lean_ctor_get(x_55, 2);
+x_72 = lean_ctor_get(x_55, 3);
+lean_dec(x_72);
+x_73 = lean_ctor_get(x_55, 0);
+lean_dec(x_73);
+x_74 = !lean_is_exclusive(x_57);
+if (x_74 == 0)
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; 
-x_66 = lean_ctor_get(x_48, 0);
-x_67 = lean_ctor_get(x_48, 1);
-x_68 = lean_ctor_get(x_48, 2);
-x_69 = lean_ctor_get(x_48, 3);
-x_70 = 1;
-lean_ctor_set(x_48, 3, x_47);
-lean_ctor_set(x_48, 2, x_37);
-lean_ctor_set(x_48, 1, x_36);
-lean_ctor_set(x_48, 0, x_35);
-lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_70);
-lean_ctor_set(x_46, 3, x_69);
-lean_ctor_set(x_46, 2, x_68);
-lean_ctor_set(x_46, 1, x_67);
-lean_ctor_set(x_46, 0, x_66);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_70);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_48);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; uint8_t x_80; 
+x_75 = lean_ctor_get(x_57, 0);
+x_76 = lean_ctor_get(x_57, 1);
+x_77 = lean_ctor_get(x_57, 2);
+x_78 = lean_ctor_get(x_57, 3);
+x_79 = 1;
+lean_ctor_set(x_57, 3, x_56);
+lean_ctor_set(x_57, 2, x_44);
+lean_ctor_set(x_57, 1, x_43);
+lean_ctor_set(x_57, 0, x_42);
+lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_79);
+lean_ctor_set(x_55, 3, x_78);
+lean_ctor_set(x_55, 2, x_77);
+lean_ctor_set(x_55, 1, x_76);
+lean_ctor_set(x_55, 0, x_75);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_79);
+x_80 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_57);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_80);
 return x_1;
 }
 else
 {
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; 
-x_71 = lean_ctor_get(x_48, 0);
-x_72 = lean_ctor_get(x_48, 1);
-x_73 = lean_ctor_get(x_48, 2);
-x_74 = lean_ctor_get(x_48, 3);
-lean_inc(x_74);
-lean_inc(x_73);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_dec(x_48);
-x_75 = 1;
-x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_35);
-lean_ctor_set(x_76, 1, x_36);
-lean_ctor_set(x_76, 2, x_37);
-lean_ctor_set(x_76, 3, x_47);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
-lean_ctor_set(x_46, 3, x_74);
-lean_ctor_set(x_46, 2, x_73);
-lean_ctor_set(x_46, 1, x_72);
-lean_ctor_set(x_46, 0, x_71);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_75);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_76);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-}
-else
-{
-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; uint8_t x_84; lean_object* x_85; lean_object* x_86; 
-x_77 = lean_ctor_get(x_46, 1);
-x_78 = lean_ctor_get(x_46, 2);
-lean_inc(x_78);
-lean_inc(x_77);
-lean_dec(x_46);
-x_79 = lean_ctor_get(x_48, 0);
-lean_inc(x_79);
-x_80 = lean_ctor_get(x_48, 1);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_48, 2);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_48, 3);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; lean_object* x_86; uint8_t x_87; 
+x_81 = lean_ctor_get(x_57, 0);
+x_82 = lean_ctor_get(x_57, 1);
+x_83 = lean_ctor_get(x_57, 2);
+x_84 = lean_ctor_get(x_57, 3);
+lean_inc(x_84);
+lean_inc(x_83);
 lean_inc(x_82);
-if (lean_is_exclusive(x_48)) {
- lean_ctor_release(x_48, 0);
- lean_ctor_release(x_48, 1);
- lean_ctor_release(x_48, 2);
- lean_ctor_release(x_48, 3);
- x_83 = x_48;
-} else {
- lean_dec_ref(x_48);
- x_83 = lean_box(0);
-}
-x_84 = 1;
-if (lean_is_scalar(x_83)) {
- x_85 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_85 = x_83;
-}
-lean_ctor_set(x_85, 0, x_35);
-lean_ctor_set(x_85, 1, x_36);
-lean_ctor_set(x_85, 2, x_37);
-lean_ctor_set(x_85, 3, x_47);
-lean_ctor_set_uint8(x_85, sizeof(void*)*4, x_84);
+lean_inc(x_81);
+lean_dec(x_57);
+x_85 = 1;
 x_86 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_86, 0, x_79);
-lean_ctor_set(x_86, 1, x_80);
-lean_ctor_set(x_86, 2, x_81);
-lean_ctor_set(x_86, 3, x_82);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_84);
-lean_ctor_set(x_1, 3, x_86);
-lean_ctor_set(x_1, 2, x_78);
-lean_ctor_set(x_1, 1, x_77);
-lean_ctor_set(x_1, 0, x_85);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_ctor_set(x_86, 0, x_42);
+lean_ctor_set(x_86, 1, x_43);
+lean_ctor_set(x_86, 2, x_44);
+lean_ctor_set(x_86, 3, x_56);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+lean_ctor_set(x_55, 3, x_84);
+lean_ctor_set(x_55, 2, x_83);
+lean_ctor_set(x_55, 1, x_82);
+lean_ctor_set(x_55, 0, x_81);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_85);
+x_87 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_87);
 return x_1;
 }
 }
 else
 {
-uint8_t x_87; 
-x_87 = !lean_is_exclusive(x_46);
-if (x_87 == 0)
-{
-lean_object* x_88; lean_object* x_89; uint8_t x_90; 
-x_88 = lean_ctor_get(x_46, 3);
-lean_dec(x_88);
-x_89 = lean_ctor_get(x_46, 0);
-lean_dec(x_89);
-x_90 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_90);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-else
-{
-lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; 
-x_91 = lean_ctor_get(x_46, 1);
-x_92 = lean_ctor_get(x_46, 2);
-lean_inc(x_92);
+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; uint8_t x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; 
+x_88 = lean_ctor_get(x_55, 1);
+x_89 = lean_ctor_get(x_55, 2);
+lean_inc(x_89);
+lean_inc(x_88);
+lean_dec(x_55);
+x_90 = lean_ctor_get(x_57, 0);
+lean_inc(x_90);
+x_91 = lean_ctor_get(x_57, 1);
 lean_inc(x_91);
-lean_dec(x_46);
-x_93 = 0;
-x_94 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_94, 0, x_47);
-lean_ctor_set(x_94, 1, x_91);
-lean_ctor_set(x_94, 2, x_92);
-lean_ctor_set(x_94, 3, x_48);
-lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_94);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+x_92 = lean_ctor_get(x_57, 2);
+lean_inc(x_92);
+x_93 = lean_ctor_get(x_57, 3);
+lean_inc(x_93);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ lean_ctor_release(x_57, 2);
+ lean_ctor_release(x_57, 3);
+ x_94 = x_57;
+} else {
+ lean_dec_ref(x_57);
+ x_94 = lean_box(0);
+}
+x_95 = 1;
+if (lean_is_scalar(x_94)) {
+ x_96 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_96 = x_94;
+}
+lean_ctor_set(x_96, 0, x_42);
+lean_ctor_set(x_96, 1, x_43);
+lean_ctor_set(x_96, 2, x_44);
+lean_ctor_set(x_96, 3, x_56);
+lean_ctor_set_uint8(x_96, sizeof(void*)*4, x_95);
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_90);
+lean_ctor_set(x_97, 1, x_91);
+lean_ctor_set(x_97, 2, x_92);
+lean_ctor_set(x_97, 3, x_93);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_95);
+x_98 = 0;
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set(x_1, 2, x_89);
+lean_ctor_set(x_1, 1, x_88);
+lean_ctor_set(x_1, 0, x_96);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_95; 
-x_95 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
-if (x_95 == 0)
+uint8_t x_99; 
+x_99 = !lean_is_exclusive(x_55);
+if (x_99 == 0)
 {
-uint8_t x_96; 
-x_96 = !lean_is_exclusive(x_46);
-if (x_96 == 0)
-{
-lean_object* x_97; uint8_t x_98; 
-x_97 = lean_ctor_get(x_46, 0);
-lean_dec(x_97);
-x_98 = !lean_is_exclusive(x_47);
-if (x_98 == 0)
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; uint8_t x_103; 
-x_99 = lean_ctor_get(x_47, 0);
-x_100 = lean_ctor_get(x_47, 1);
-x_101 = lean_ctor_get(x_47, 2);
-x_102 = lean_ctor_get(x_47, 3);
+lean_object* x_100; lean_object* x_101; uint8_t x_102; uint8_t x_103; 
+x_100 = lean_ctor_get(x_55, 3);
+lean_dec(x_100);
+x_101 = lean_ctor_get(x_55, 0);
+lean_dec(x_101);
+x_102 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_102);
 x_103 = 1;
-lean_ctor_set(x_47, 3, x_99);
-lean_ctor_set(x_47, 2, x_37);
-lean_ctor_set(x_47, 1, x_36);
-lean_ctor_set(x_47, 0, x_35);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_103);
-lean_ctor_set(x_46, 0, x_102);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_103);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_101);
-lean_ctor_set(x_1, 1, x_100);
-lean_ctor_set(x_1, 0, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_103);
 return x_1;
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; 
-x_104 = lean_ctor_get(x_47, 0);
-x_105 = lean_ctor_get(x_47, 1);
-x_106 = lean_ctor_get(x_47, 2);
-x_107 = lean_ctor_get(x_47, 3);
-lean_inc(x_107);
-lean_inc(x_106);
+lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; uint8_t x_108; 
+x_104 = lean_ctor_get(x_55, 1);
+x_105 = lean_ctor_get(x_55, 2);
 lean_inc(x_105);
 lean_inc(x_104);
-lean_dec(x_47);
+lean_dec(x_55);
+x_106 = 0;
+x_107 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_107, 0, x_56);
+lean_ctor_set(x_107, 1, x_104);
+lean_ctor_set(x_107, 2, x_105);
+lean_ctor_set(x_107, 3, x_57);
+lean_ctor_set_uint8(x_107, sizeof(void*)*4, x_106);
 x_108 = 1;
-x_109 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_109, 0, x_35);
-lean_ctor_set(x_109, 1, x_36);
-lean_ctor_set(x_109, 2, x_37);
-lean_ctor_set(x_109, 3, x_104);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-lean_ctor_set(x_46, 0, x_107);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_106);
-lean_ctor_set(x_1, 1, x_105);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_107);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; lean_object* x_120; 
-x_110 = lean_ctor_get(x_46, 1);
-x_111 = lean_ctor_get(x_46, 2);
-x_112 = lean_ctor_get(x_46, 3);
-lean_inc(x_112);
-lean_inc(x_111);
-lean_inc(x_110);
-lean_dec(x_46);
-x_113 = lean_ctor_get(x_47, 0);
-lean_inc(x_113);
-x_114 = lean_ctor_get(x_47, 1);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_47, 2);
-lean_inc(x_115);
-x_116 = lean_ctor_get(x_47, 3);
-lean_inc(x_116);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_117 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_117 = lean_box(0);
-}
-x_118 = 1;
-if (lean_is_scalar(x_117)) {
- x_119 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_119 = x_117;
-}
-lean_ctor_set(x_119, 0, x_35);
-lean_ctor_set(x_119, 1, x_36);
-lean_ctor_set(x_119, 2, x_37);
-lean_ctor_set(x_119, 3, x_113);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-x_120 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_120, 0, x_116);
-lean_ctor_set(x_120, 1, x_110);
-lean_ctor_set(x_120, 2, x_111);
-lean_ctor_set(x_120, 3, x_112);
-lean_ctor_set_uint8(x_120, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_120);
+uint8_t x_109; 
+x_109 = lean_ctor_get_uint8(x_56, sizeof(void*)*4);
+if (x_109 == 0)
+{
+uint8_t x_110; 
+x_110 = !lean_is_exclusive(x_55);
+if (x_110 == 0)
+{
+lean_object* x_111; uint8_t x_112; 
+x_111 = lean_ctor_get(x_55, 0);
+lean_dec(x_111);
+x_112 = !lean_is_exclusive(x_56);
+if (x_112 == 0)
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint8_t x_117; uint8_t x_118; 
+x_113 = lean_ctor_get(x_56, 0);
+x_114 = lean_ctor_get(x_56, 1);
+x_115 = lean_ctor_get(x_56, 2);
+x_116 = lean_ctor_get(x_56, 3);
+x_117 = 1;
+lean_ctor_set(x_56, 3, x_113);
+lean_ctor_set(x_56, 2, x_44);
+lean_ctor_set(x_56, 1, x_43);
+lean_ctor_set(x_56, 0, x_42);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_117);
+lean_ctor_set(x_55, 0, x_116);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_117);
+x_118 = 0;
+lean_ctor_set(x_1, 3, x_55);
 lean_ctor_set(x_1, 2, x_115);
 lean_ctor_set(x_1, 1, x_114);
-lean_ctor_set(x_1, 0, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 0, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_118);
 return x_1;
 }
-}
 else
 {
-lean_object* x_121; 
-x_121 = lean_ctor_get(x_46, 3);
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; lean_object* x_124; uint8_t x_125; 
+x_119 = lean_ctor_get(x_56, 0);
+x_120 = lean_ctor_get(x_56, 1);
+x_121 = lean_ctor_get(x_56, 2);
+x_122 = lean_ctor_get(x_56, 3);
+lean_inc(x_122);
 lean_inc(x_121);
-if (lean_obj_tag(x_121) == 0)
-{
-uint8_t x_122; 
-x_122 = !lean_is_exclusive(x_46);
-if (x_122 == 0)
-{
-lean_object* x_123; lean_object* x_124; uint8_t x_125; 
-x_123 = lean_ctor_get(x_46, 3);
-lean_dec(x_123);
-x_124 = lean_ctor_get(x_46, 0);
-lean_dec(x_124);
+lean_inc(x_120);
+lean_inc(x_119);
+lean_dec(x_56);
+x_123 = 1;
+x_124 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_124, 0, x_42);
+lean_ctor_set(x_124, 1, x_43);
+lean_ctor_set(x_124, 2, x_44);
+lean_ctor_set(x_124, 3, x_119);
+lean_ctor_set_uint8(x_124, sizeof(void*)*4, x_123);
+lean_ctor_set(x_55, 0, x_122);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_123);
 x_125 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_125);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_124);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_125);
 return x_1;
 }
+}
 else
 {
-lean_object* x_126; lean_object* x_127; uint8_t x_128; lean_object* x_129; 
-x_126 = lean_ctor_get(x_46, 1);
-x_127 = lean_ctor_get(x_46, 2);
+lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; uint8_t x_137; 
+x_126 = lean_ctor_get(x_55, 1);
+x_127 = lean_ctor_get(x_55, 2);
+x_128 = lean_ctor_get(x_55, 3);
+lean_inc(x_128);
 lean_inc(x_127);
 lean_inc(x_126);
-lean_dec(x_46);
-x_128 = 0;
-x_129 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_129, 0, x_47);
-lean_ctor_set(x_129, 1, x_126);
-lean_ctor_set(x_129, 2, x_127);
-lean_ctor_set(x_129, 3, x_121);
-lean_ctor_set_uint8(x_129, sizeof(void*)*4, x_128);
-lean_ctor_set(x_1, 3, x_129);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_dec(x_55);
+x_129 = lean_ctor_get(x_56, 0);
+lean_inc(x_129);
+x_130 = lean_ctor_get(x_56, 1);
+lean_inc(x_130);
+x_131 = lean_ctor_get(x_56, 2);
+lean_inc(x_131);
+x_132 = lean_ctor_get(x_56, 3);
+lean_inc(x_132);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_133 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_133 = lean_box(0);
+}
+x_134 = 1;
+if (lean_is_scalar(x_133)) {
+ x_135 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_135 = x_133;
+}
+lean_ctor_set(x_135, 0, x_42);
+lean_ctor_set(x_135, 1, x_43);
+lean_ctor_set(x_135, 2, x_44);
+lean_ctor_set(x_135, 3, x_129);
+lean_ctor_set_uint8(x_135, sizeof(void*)*4, x_134);
+x_136 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_136, 0, x_132);
+lean_ctor_set(x_136, 1, x_126);
+lean_ctor_set(x_136, 2, x_127);
+lean_ctor_set(x_136, 3, x_128);
+lean_ctor_set_uint8(x_136, sizeof(void*)*4, x_134);
+x_137 = 0;
+lean_ctor_set(x_1, 3, x_136);
+lean_ctor_set(x_1, 2, x_131);
+lean_ctor_set(x_1, 1, x_130);
+lean_ctor_set(x_1, 0, x_135);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_137);
 return x_1;
 }
 }
 else
 {
-uint8_t x_130; 
-x_130 = lean_ctor_get_uint8(x_121, sizeof(void*)*4);
-if (x_130 == 0)
+lean_object* x_138; 
+x_138 = lean_ctor_get(x_55, 3);
+lean_inc(x_138);
+if (lean_obj_tag(x_138) == 0)
 {
-uint8_t x_131; 
-lean_free_object(x_1);
-x_131 = !lean_is_exclusive(x_46);
-if (x_131 == 0)
-{
-lean_object* x_132; lean_object* x_133; uint8_t x_134; 
-x_132 = lean_ctor_get(x_46, 3);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_46, 0);
-lean_dec(x_133);
-x_134 = !lean_is_exclusive(x_121);
-if (x_134 == 0)
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; 
-x_135 = lean_ctor_get(x_121, 0);
-x_136 = lean_ctor_get(x_121, 1);
-x_137 = lean_ctor_get(x_121, 2);
-x_138 = lean_ctor_get(x_121, 3);
-lean_inc(x_47);
-lean_ctor_set(x_121, 3, x_47);
-lean_ctor_set(x_121, 2, x_37);
-lean_ctor_set(x_121, 1, x_36);
-lean_ctor_set(x_121, 0, x_35);
-x_139 = !lean_is_exclusive(x_47);
+uint8_t x_139; 
+x_139 = !lean_is_exclusive(x_55);
 if (x_139 == 0)
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_140 = lean_ctor_get(x_47, 3);
+lean_object* x_140; lean_object* x_141; uint8_t x_142; uint8_t x_143; 
+x_140 = lean_ctor_get(x_55, 3);
 lean_dec(x_140);
-x_141 = lean_ctor_get(x_47, 2);
+x_141 = lean_ctor_get(x_55, 0);
 lean_dec(x_141);
-x_142 = lean_ctor_get(x_47, 1);
-lean_dec(x_142);
-x_143 = lean_ctor_get(x_47, 0);
-lean_dec(x_143);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-lean_ctor_set(x_47, 3, x_138);
-lean_ctor_set(x_47, 2, x_137);
-lean_ctor_set(x_47, 1, x_136);
-lean_ctor_set(x_47, 0, x_135);
-lean_ctor_set(x_46, 3, x_47);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-else
-{
-lean_object* x_144; 
-lean_dec(x_47);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-x_144 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_144, 0, x_135);
-lean_ctor_set(x_144, 1, x_136);
-lean_ctor_set(x_144, 2, x_137);
-lean_ctor_set(x_144, 3, x_138);
-lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_144);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
-x_145 = lean_ctor_get(x_121, 0);
-x_146 = lean_ctor_get(x_121, 1);
-x_147 = lean_ctor_get(x_121, 2);
-x_148 = lean_ctor_get(x_121, 3);
-lean_inc(x_148);
-lean_inc(x_147);
-lean_inc(x_146);
-lean_inc(x_145);
-lean_dec(x_121);
-lean_inc(x_47);
-x_149 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_149, 0, x_35);
-lean_ctor_set(x_149, 1, x_36);
-lean_ctor_set(x_149, 2, x_37);
-lean_ctor_set(x_149, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_150 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_145);
-lean_ctor_set(x_151, 1, x_146);
-lean_ctor_set(x_151, 2, x_147);
-lean_ctor_set(x_151, 3, x_148);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_151);
-lean_ctor_set(x_46, 0, x_149);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
-x_152 = lean_ctor_get(x_46, 1);
-x_153 = lean_ctor_get(x_46, 2);
-lean_inc(x_153);
-lean_inc(x_152);
-lean_dec(x_46);
-x_154 = lean_ctor_get(x_121, 0);
-lean_inc(x_154);
-x_155 = lean_ctor_get(x_121, 1);
-lean_inc(x_155);
-x_156 = lean_ctor_get(x_121, 2);
-lean_inc(x_156);
-x_157 = lean_ctor_get(x_121, 3);
-lean_inc(x_157);
-if (lean_is_exclusive(x_121)) {
- lean_ctor_release(x_121, 0);
- lean_ctor_release(x_121, 1);
- lean_ctor_release(x_121, 2);
- lean_ctor_release(x_121, 3);
- x_158 = x_121;
-} else {
- lean_dec_ref(x_121);
- x_158 = lean_box(0);
-}
-lean_inc(x_47);
-if (lean_is_scalar(x_158)) {
- x_159 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_159 = x_158;
-}
-lean_ctor_set(x_159, 0, x_35);
-lean_ctor_set(x_159, 1, x_36);
-lean_ctor_set(x_159, 2, x_37);
-lean_ctor_set(x_159, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_160 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_160 = lean_box(0);
-}
-lean_ctor_set_uint8(x_159, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_160)) {
- x_161 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_161 = x_160;
-}
-lean_ctor_set(x_161, 0, x_154);
-lean_ctor_set(x_161, 1, x_155);
-lean_ctor_set(x_161, 2, x_156);
-lean_ctor_set(x_161, 3, x_157);
-lean_ctor_set_uint8(x_161, sizeof(void*)*4, x_95);
-x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_159);
-lean_ctor_set(x_162, 1, x_152);
-lean_ctor_set(x_162, 2, x_153);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_130);
-return x_162;
-}
-}
-else
-{
-uint8_t x_163; 
-x_163 = !lean_is_exclusive(x_46);
-if (x_163 == 0)
-{
-lean_object* x_164; lean_object* x_165; uint8_t x_166; 
-x_164 = lean_ctor_get(x_46, 3);
-lean_dec(x_164);
-x_165 = lean_ctor_get(x_46, 0);
-lean_dec(x_165);
-x_166 = !lean_is_exclusive(x_47);
-if (x_166 == 0)
-{
-uint8_t x_167; 
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_130);
-x_167 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_167);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
+x_142 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_142);
+x_143 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_143);
 return x_1;
 }
 else
 {
-lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; 
-x_168 = lean_ctor_get(x_47, 0);
-x_169 = lean_ctor_get(x_47, 1);
-x_170 = lean_ctor_get(x_47, 2);
-x_171 = lean_ctor_get(x_47, 3);
-lean_inc(x_171);
+lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; uint8_t x_148; 
+x_144 = lean_ctor_get(x_55, 1);
+x_145 = lean_ctor_get(x_55, 2);
+lean_inc(x_145);
+lean_inc(x_144);
+lean_dec(x_55);
+x_146 = 0;
+x_147 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_147, 0, x_56);
+lean_ctor_set(x_147, 1, x_144);
+lean_ctor_set(x_147, 2, x_145);
+lean_ctor_set(x_147, 3, x_138);
+lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_146);
+x_148 = 1;
+lean_ctor_set(x_1, 3, x_147);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_148);
+return x_1;
+}
+}
+else
+{
+uint8_t x_149; 
+x_149 = lean_ctor_get_uint8(x_138, sizeof(void*)*4);
+if (x_149 == 0)
+{
+uint8_t x_150; 
+lean_free_object(x_1);
+x_150 = !lean_is_exclusive(x_55);
+if (x_150 == 0)
+{
+lean_object* x_151; lean_object* x_152; uint8_t x_153; 
+x_151 = lean_ctor_get(x_55, 3);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_55, 0);
+lean_dec(x_152);
+x_153 = !lean_is_exclusive(x_138);
+if (x_153 == 0)
+{
+lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; uint8_t x_158; uint8_t x_159; 
+x_154 = lean_ctor_get(x_138, 0);
+x_155 = lean_ctor_get(x_138, 1);
+x_156 = lean_ctor_get(x_138, 2);
+x_157 = lean_ctor_get(x_138, 3);
+x_158 = 1;
+lean_inc(x_56);
+lean_ctor_set(x_138, 3, x_56);
+lean_ctor_set(x_138, 2, x_44);
+lean_ctor_set(x_138, 1, x_43);
+lean_ctor_set(x_138, 0, x_42);
+x_159 = !lean_is_exclusive(x_56);
+if (x_159 == 0)
+{
+lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; uint8_t x_164; 
+x_160 = lean_ctor_get(x_56, 3);
+lean_dec(x_160);
+x_161 = lean_ctor_get(x_56, 2);
+lean_dec(x_161);
+x_162 = lean_ctor_get(x_56, 1);
+lean_dec(x_162);
+x_163 = lean_ctor_get(x_56, 0);
+lean_dec(x_163);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+lean_ctor_set(x_56, 3, x_157);
+lean_ctor_set(x_56, 2, x_156);
+lean_ctor_set(x_56, 1, x_155);
+lean_ctor_set(x_56, 0, x_154);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_158);
+x_164 = 0;
+lean_ctor_set(x_55, 3, x_56);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_164);
+return x_55;
+}
+else
+{
+lean_object* x_165; uint8_t x_166; 
+lean_dec(x_56);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+x_165 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_165, 0, x_154);
+lean_ctor_set(x_165, 1, x_155);
+lean_ctor_set(x_165, 2, x_156);
+lean_ctor_set(x_165, 3, x_157);
+lean_ctor_set_uint8(x_165, sizeof(void*)*4, x_158);
+x_166 = 0;
+lean_ctor_set(x_55, 3, x_165);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_166);
+return x_55;
+}
+}
+else
+{
+lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; 
+x_167 = lean_ctor_get(x_138, 0);
+x_168 = lean_ctor_get(x_138, 1);
+x_169 = lean_ctor_get(x_138, 2);
+x_170 = lean_ctor_get(x_138, 3);
 lean_inc(x_170);
 lean_inc(x_169);
 lean_inc(x_168);
-lean_dec(x_47);
+lean_inc(x_167);
+lean_dec(x_138);
+x_171 = 1;
+lean_inc(x_56);
 x_172 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_172, 0, x_168);
-lean_ctor_set(x_172, 1, x_169);
-lean_ctor_set(x_172, 2, x_170);
-lean_ctor_set(x_172, 3, x_171);
-lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_130);
-x_173 = 0;
-lean_ctor_set(x_46, 0, x_172);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_173);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
+lean_ctor_set(x_172, 0, x_42);
+lean_ctor_set(x_172, 1, x_43);
+lean_ctor_set(x_172, 2, x_44);
+lean_ctor_set(x_172, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_173 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_173 = lean_box(0);
+}
+lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_171);
+if (lean_is_scalar(x_173)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_174 = x_173;
+}
+lean_ctor_set(x_174, 0, x_167);
+lean_ctor_set(x_174, 1, x_168);
+lean_ctor_set(x_174, 2, x_169);
+lean_ctor_set(x_174, 3, x_170);
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_171);
+x_175 = 0;
+lean_ctor_set(x_55, 3, x_174);
+lean_ctor_set(x_55, 0, x_172);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_175);
+return x_55;
 }
 }
 else
 {
-lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; uint8_t x_182; lean_object* x_183; 
-x_174 = lean_ctor_get(x_46, 1);
-x_175 = lean_ctor_get(x_46, 2);
-lean_inc(x_175);
-lean_inc(x_174);
-lean_dec(x_46);
-x_176 = lean_ctor_get(x_47, 0);
-lean_inc(x_176);
-x_177 = lean_ctor_get(x_47, 1);
+lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; uint8_t x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; uint8_t x_187; lean_object* x_188; 
+x_176 = lean_ctor_get(x_55, 1);
+x_177 = lean_ctor_get(x_55, 2);
 lean_inc(x_177);
-x_178 = lean_ctor_get(x_47, 2);
+lean_inc(x_176);
+lean_dec(x_55);
+x_178 = lean_ctor_get(x_138, 0);
 lean_inc(x_178);
-x_179 = lean_ctor_get(x_47, 3);
+x_179 = lean_ctor_get(x_138, 1);
 lean_inc(x_179);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_180 = x_47;
+x_180 = lean_ctor_get(x_138, 2);
+lean_inc(x_180);
+x_181 = lean_ctor_get(x_138, 3);
+lean_inc(x_181);
+if (lean_is_exclusive(x_138)) {
+ lean_ctor_release(x_138, 0);
+ lean_ctor_release(x_138, 1);
+ lean_ctor_release(x_138, 2);
+ lean_ctor_release(x_138, 3);
+ x_182 = x_138;
 } else {
- lean_dec_ref(x_47);
- x_180 = lean_box(0);
+ lean_dec_ref(x_138);
+ x_182 = lean_box(0);
 }
-if (lean_is_scalar(x_180)) {
- x_181 = lean_alloc_ctor(1, 4, 1);
+x_183 = 1;
+lean_inc(x_56);
+if (lean_is_scalar(x_182)) {
+ x_184 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_181 = x_180;
-}
-lean_ctor_set(x_181, 0, x_176);
-lean_ctor_set(x_181, 1, x_177);
-lean_ctor_set(x_181, 2, x_178);
-lean_ctor_set(x_181, 3, x_179);
-lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_130);
-x_182 = 0;
-x_183 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_183, 0, x_181);
-lean_ctor_set(x_183, 1, x_174);
-lean_ctor_set(x_183, 2, x_175);
-lean_ctor_set(x_183, 3, x_121);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_182);
-lean_ctor_set(x_1, 3, x_183);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
-}
-}
-}
+ x_184 = x_182;
 }
+lean_ctor_set(x_184, 0, x_42);
+lean_ctor_set(x_184, 1, x_43);
+lean_ctor_set(x_184, 2, x_44);
+lean_ctor_set(x_184, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_185 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_185 = lean_box(0);
 }
+lean_ctor_set_uint8(x_184, sizeof(void*)*4, x_183);
+if (lean_is_scalar(x_185)) {
+ x_186 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_186 = x_185;
 }
+lean_ctor_set(x_186, 0, x_178);
+lean_ctor_set(x_186, 1, x_179);
+lean_ctor_set(x_186, 2, x_180);
+lean_ctor_set(x_186, 3, x_181);
+lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_183);
+x_187 = 0;
+x_188 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_188, 0, x_184);
+lean_ctor_set(x_188, 1, x_176);
+lean_ctor_set(x_188, 2, x_177);
+lean_ctor_set(x_188, 3, x_186);
+lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_187);
+return x_188;
 }
 }
 else
 {
-uint8_t x_184; 
-x_184 = l_Std_RBNode_isRed___rarg(x_35);
-if (x_184 == 0)
-{
-lean_object* x_185; 
-x_185 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_35, x_2, x_3);
-lean_ctor_set(x_1, 0, x_185);
-return x_1;
-}
-else
-{
-lean_object* x_186; lean_object* x_187; 
-x_186 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_35, x_2, x_3);
-x_187 = lean_ctor_get(x_186, 0);
-lean_inc(x_187);
-if (lean_obj_tag(x_187) == 0)
-{
-lean_object* x_188; 
-x_188 = lean_ctor_get(x_186, 3);
-lean_inc(x_188);
-if (lean_obj_tag(x_188) == 0)
-{
 uint8_t x_189; 
-x_189 = !lean_is_exclusive(x_186);
+x_189 = !lean_is_exclusive(x_55);
 if (x_189 == 0)
 {
-lean_object* x_190; lean_object* x_191; uint8_t x_192; uint8_t x_193; 
-x_190 = lean_ctor_get(x_186, 3);
+lean_object* x_190; lean_object* x_191; uint8_t x_192; 
+x_190 = lean_ctor_get(x_55, 3);
 lean_dec(x_190);
-x_191 = lean_ctor_get(x_186, 0);
+x_191 = lean_ctor_get(x_55, 0);
 lean_dec(x_191);
-x_192 = 0;
-lean_ctor_set(x_186, 0, x_188);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_192);
-x_193 = 1;
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_193);
+x_192 = !lean_is_exclusive(x_56);
+if (x_192 == 0)
+{
+uint8_t x_193; uint8_t x_194; 
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_149);
+x_193 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_193);
+x_194 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_194);
 return x_1;
 }
 else
 {
-lean_object* x_194; lean_object* x_195; uint8_t x_196; lean_object* x_197; uint8_t x_198; 
-x_194 = lean_ctor_get(x_186, 1);
-x_195 = lean_ctor_get(x_186, 2);
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; uint8_t x_201; 
+x_195 = lean_ctor_get(x_56, 0);
+x_196 = lean_ctor_get(x_56, 1);
+x_197 = lean_ctor_get(x_56, 2);
+x_198 = lean_ctor_get(x_56, 3);
+lean_inc(x_198);
+lean_inc(x_197);
+lean_inc(x_196);
 lean_inc(x_195);
-lean_inc(x_194);
-lean_dec(x_186);
-x_196 = 0;
-x_197 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_197, 0, x_188);
-lean_ctor_set(x_197, 1, x_194);
-lean_ctor_set(x_197, 2, x_195);
-lean_ctor_set(x_197, 3, x_188);
-lean_ctor_set_uint8(x_197, sizeof(void*)*4, x_196);
-x_198 = 1;
-lean_ctor_set(x_1, 0, x_197);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_198);
+lean_dec(x_56);
+x_199 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_199, 0, x_195);
+lean_ctor_set(x_199, 1, x_196);
+lean_ctor_set(x_199, 2, x_197);
+lean_ctor_set(x_199, 3, x_198);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_149);
+x_200 = 0;
+lean_ctor_set(x_55, 0, x_199);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_200);
+x_201 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_201);
 return x_1;
 }
 }
 else
 {
-uint8_t x_199; 
-x_199 = lean_ctor_get_uint8(x_188, sizeof(void*)*4);
-if (x_199 == 0)
-{
-uint8_t x_200; 
-x_200 = !lean_is_exclusive(x_186);
-if (x_200 == 0)
-{
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; 
-x_201 = lean_ctor_get(x_186, 1);
-x_202 = lean_ctor_get(x_186, 2);
-x_203 = lean_ctor_get(x_186, 3);
-lean_dec(x_203);
-x_204 = lean_ctor_get(x_186, 0);
-lean_dec(x_204);
-x_205 = !lean_is_exclusive(x_188);
-if (x_205 == 0)
-{
-lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; 
-x_206 = lean_ctor_get(x_188, 0);
-x_207 = lean_ctor_get(x_188, 1);
-x_208 = lean_ctor_get(x_188, 2);
-x_209 = lean_ctor_get(x_188, 3);
-x_210 = 1;
-lean_ctor_set(x_188, 3, x_206);
-lean_ctor_set(x_188, 2, x_202);
-lean_ctor_set(x_188, 1, x_201);
-lean_ctor_set(x_188, 0, x_187);
-lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_210);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_209);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_210);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_208);
-lean_ctor_set(x_1, 1, x_207);
-lean_ctor_set(x_1, 0, x_188);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; lean_object* x_211; uint8_t x_212; 
+x_202 = lean_ctor_get(x_55, 1);
+x_203 = lean_ctor_get(x_55, 2);
+lean_inc(x_203);
+lean_inc(x_202);
+lean_dec(x_55);
+x_204 = lean_ctor_get(x_56, 0);
+lean_inc(x_204);
+x_205 = lean_ctor_get(x_56, 1);
+lean_inc(x_205);
+x_206 = lean_ctor_get(x_56, 2);
+lean_inc(x_206);
+x_207 = lean_ctor_get(x_56, 3);
+lean_inc(x_207);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_208 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_208 = lean_box(0);
+}
+if (lean_is_scalar(x_208)) {
+ x_209 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_209 = x_208;
+}
+lean_ctor_set(x_209, 0, x_204);
+lean_ctor_set(x_209, 1, x_205);
+lean_ctor_set(x_209, 2, x_206);
+lean_ctor_set(x_209, 3, x_207);
+lean_ctor_set_uint8(x_209, sizeof(void*)*4, x_149);
+x_210 = 0;
+x_211 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_211, 0, x_209);
+lean_ctor_set(x_211, 1, x_202);
+lean_ctor_set(x_211, 2, x_203);
+lean_ctor_set(x_211, 3, x_138);
+lean_ctor_set_uint8(x_211, sizeof(void*)*4, x_210);
+x_212 = 1;
+lean_ctor_set(x_1, 3, x_211);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_212);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; uint8_t x_215; lean_object* x_216; 
-x_211 = lean_ctor_get(x_188, 0);
-x_212 = lean_ctor_get(x_188, 1);
-x_213 = lean_ctor_get(x_188, 2);
-x_214 = lean_ctor_get(x_188, 3);
-lean_inc(x_214);
-lean_inc(x_213);
-lean_inc(x_212);
-lean_inc(x_211);
-lean_dec(x_188);
+uint8_t x_213; 
+x_213 = l_Std_RBNode_isRed___rarg(x_42);
+if (x_213 == 0)
+{
+lean_object* x_214; uint8_t x_215; 
+x_214 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_42, x_2, x_3);
 x_215 = 1;
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_187);
-lean_ctor_set(x_216, 1, x_201);
-lean_ctor_set(x_216, 2, x_202);
-lean_ctor_set(x_216, 3, x_211);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_215);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_214);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_215);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_213);
-lean_ctor_set(x_1, 1, x_212);
-lean_ctor_set(x_1, 0, x_216);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_ctor_set(x_1, 0, x_214);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_215);
 return x_1;
 }
-}
 else
 {
-lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; uint8_t x_224; lean_object* x_225; lean_object* x_226; 
-x_217 = lean_ctor_get(x_186, 1);
-x_218 = lean_ctor_get(x_186, 2);
-lean_inc(x_218);
+lean_object* x_216; lean_object* x_217; 
+x_216 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_42, x_2, x_3);
+x_217 = lean_ctor_get(x_216, 0);
 lean_inc(x_217);
-lean_dec(x_186);
-x_219 = lean_ctor_get(x_188, 0);
-lean_inc(x_219);
-x_220 = lean_ctor_get(x_188, 1);
-lean_inc(x_220);
-x_221 = lean_ctor_get(x_188, 2);
-lean_inc(x_221);
-x_222 = lean_ctor_get(x_188, 3);
-lean_inc(x_222);
-if (lean_is_exclusive(x_188)) {
- lean_ctor_release(x_188, 0);
- lean_ctor_release(x_188, 1);
- lean_ctor_release(x_188, 2);
- lean_ctor_release(x_188, 3);
- x_223 = x_188;
-} else {
- lean_dec_ref(x_188);
- x_223 = lean_box(0);
+if (lean_obj_tag(x_217) == 0)
+{
+lean_object* x_218; 
+x_218 = lean_ctor_get(x_216, 3);
+lean_inc(x_218);
+if (lean_obj_tag(x_218) == 0)
+{
+uint8_t x_219; 
+x_219 = !lean_is_exclusive(x_216);
+if (x_219 == 0)
+{
+lean_object* x_220; lean_object* x_221; uint8_t x_222; uint8_t x_223; 
+x_220 = lean_ctor_get(x_216, 3);
+lean_dec(x_220);
+x_221 = lean_ctor_get(x_216, 0);
+lean_dec(x_221);
+x_222 = 0;
+lean_ctor_set(x_216, 0, x_218);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_222);
+x_223 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_223);
+return x_1;
 }
-x_224 = 1;
-if (lean_is_scalar(x_223)) {
- x_225 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_225 = x_223;
-}
-lean_ctor_set(x_225, 0, x_187);
-lean_ctor_set(x_225, 1, x_217);
-lean_ctor_set(x_225, 2, x_218);
-lean_ctor_set(x_225, 3, x_219);
-lean_ctor_set_uint8(x_225, sizeof(void*)*4, x_224);
-x_226 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_226, 0, x_222);
-lean_ctor_set(x_226, 1, x_36);
-lean_ctor_set(x_226, 2, x_37);
-lean_ctor_set(x_226, 3, x_38);
-lean_ctor_set_uint8(x_226, sizeof(void*)*4, x_224);
-lean_ctor_set(x_1, 3, x_226);
-lean_ctor_set(x_1, 2, x_221);
-lean_ctor_set(x_1, 1, x_220);
-lean_ctor_set(x_1, 0, x_225);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+else
+{
+lean_object* x_224; lean_object* x_225; uint8_t x_226; lean_object* x_227; uint8_t x_228; 
+x_224 = lean_ctor_get(x_216, 1);
+x_225 = lean_ctor_get(x_216, 2);
+lean_inc(x_225);
+lean_inc(x_224);
+lean_dec(x_216);
+x_226 = 0;
+x_227 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_227, 0, x_218);
+lean_ctor_set(x_227, 1, x_224);
+lean_ctor_set(x_227, 2, x_225);
+lean_ctor_set(x_227, 3, x_218);
+lean_ctor_set_uint8(x_227, sizeof(void*)*4, x_226);
+x_228 = 1;
+lean_ctor_set(x_1, 0, x_227);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_228);
 return x_1;
 }
 }
 else
 {
-uint8_t x_227; 
-x_227 = !lean_is_exclusive(x_186);
-if (x_227 == 0)
+uint8_t x_229; 
+x_229 = lean_ctor_get_uint8(x_218, sizeof(void*)*4);
+if (x_229 == 0)
 {
-lean_object* x_228; lean_object* x_229; uint8_t x_230; 
-x_228 = lean_ctor_get(x_186, 3);
-lean_dec(x_228);
-x_229 = lean_ctor_get(x_186, 0);
-lean_dec(x_229);
-x_230 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_230);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-else
+uint8_t x_230; 
+x_230 = !lean_is_exclusive(x_216);
+if (x_230 == 0)
 {
-lean_object* x_231; lean_object* x_232; uint8_t x_233; lean_object* x_234; 
-x_231 = lean_ctor_get(x_186, 1);
-x_232 = lean_ctor_get(x_186, 2);
-lean_inc(x_232);
-lean_inc(x_231);
-lean_dec(x_186);
-x_233 = 0;
-x_234 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_234, 0, x_187);
-lean_ctor_set(x_234, 1, x_231);
-lean_ctor_set(x_234, 2, x_232);
-lean_ctor_set(x_234, 3, x_188);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_233);
-lean_ctor_set(x_1, 0, x_234);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_235; 
-x_235 = lean_ctor_get_uint8(x_187, sizeof(void*)*4);
+lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; uint8_t x_235; 
+x_231 = lean_ctor_get(x_216, 1);
+x_232 = lean_ctor_get(x_216, 2);
+x_233 = lean_ctor_get(x_216, 3);
+lean_dec(x_233);
+x_234 = lean_ctor_get(x_216, 0);
+lean_dec(x_234);
+x_235 = !lean_is_exclusive(x_218);
 if (x_235 == 0)
 {
-uint8_t x_236; 
-x_236 = !lean_is_exclusive(x_186);
-if (x_236 == 0)
-{
-lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; uint8_t x_241; 
-x_237 = lean_ctor_get(x_186, 1);
-x_238 = lean_ctor_get(x_186, 2);
-x_239 = lean_ctor_get(x_186, 3);
-x_240 = lean_ctor_get(x_186, 0);
-lean_dec(x_240);
-x_241 = !lean_is_exclusive(x_187);
-if (x_241 == 0)
-{
-uint8_t x_242; 
-x_242 = 1;
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_242);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_242);
-lean_ctor_set(x_1, 3, x_186);
+lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; uint8_t x_240; uint8_t x_241; 
+x_236 = lean_ctor_get(x_218, 0);
+x_237 = lean_ctor_get(x_218, 1);
+x_238 = lean_ctor_get(x_218, 2);
+x_239 = lean_ctor_get(x_218, 3);
+x_240 = 1;
+lean_ctor_set(x_218, 3, x_236);
+lean_ctor_set(x_218, 2, x_232);
+lean_ctor_set(x_218, 1, x_231);
+lean_ctor_set(x_218, 0, x_217);
+lean_ctor_set_uint8(x_218, sizeof(void*)*4, x_240);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_239);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_240);
+x_241 = 0;
+lean_ctor_set(x_1, 3, x_216);
 lean_ctor_set(x_1, 2, x_238);
 lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_1, 0, x_218);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_241);
 return x_1;
 }
 else
 {
-lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; 
-x_243 = lean_ctor_get(x_187, 0);
-x_244 = lean_ctor_get(x_187, 1);
-x_245 = lean_ctor_get(x_187, 2);
-x_246 = lean_ctor_get(x_187, 3);
-lean_inc(x_246);
+lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; uint8_t x_248; 
+x_242 = lean_ctor_get(x_218, 0);
+x_243 = lean_ctor_get(x_218, 1);
+x_244 = lean_ctor_get(x_218, 2);
+x_245 = lean_ctor_get(x_218, 3);
 lean_inc(x_245);
 lean_inc(x_244);
 lean_inc(x_243);
-lean_dec(x_187);
-x_247 = 1;
-x_248 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_248, 0, x_243);
-lean_ctor_set(x_248, 1, x_244);
-lean_ctor_set(x_248, 2, x_245);
-lean_ctor_set(x_248, 3, x_246);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_238);
-lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_inc(x_242);
+lean_dec(x_218);
+x_246 = 1;
+x_247 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_247, 0, x_217);
+lean_ctor_set(x_247, 1, x_231);
+lean_ctor_set(x_247, 2, x_232);
+lean_ctor_set(x_247, 3, x_242);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_245);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_246);
+x_248 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_244);
+lean_ctor_set(x_1, 1, x_243);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_248);
 return x_1;
 }
 }
 else
 {
-lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; lean_object* x_259; 
-x_249 = lean_ctor_get(x_186, 1);
-x_250 = lean_ctor_get(x_186, 2);
-x_251 = lean_ctor_get(x_186, 3);
-lean_inc(x_251);
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; lean_object* x_257; lean_object* x_258; uint8_t x_259; 
+x_249 = lean_ctor_get(x_216, 1);
+x_250 = lean_ctor_get(x_216, 2);
 lean_inc(x_250);
 lean_inc(x_249);
-lean_dec(x_186);
-x_252 = lean_ctor_get(x_187, 0);
+lean_dec(x_216);
+x_251 = lean_ctor_get(x_218, 0);
+lean_inc(x_251);
+x_252 = lean_ctor_get(x_218, 1);
 lean_inc(x_252);
-x_253 = lean_ctor_get(x_187, 1);
+x_253 = lean_ctor_get(x_218, 2);
 lean_inc(x_253);
-x_254 = lean_ctor_get(x_187, 2);
+x_254 = lean_ctor_get(x_218, 3);
 lean_inc(x_254);
-x_255 = lean_ctor_get(x_187, 3);
-lean_inc(x_255);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_256 = x_187;
+if (lean_is_exclusive(x_218)) {
+ lean_ctor_release(x_218, 0);
+ lean_ctor_release(x_218, 1);
+ lean_ctor_release(x_218, 2);
+ lean_ctor_release(x_218, 3);
+ x_255 = x_218;
 } else {
- lean_dec_ref(x_187);
- x_256 = lean_box(0);
+ lean_dec_ref(x_218);
+ x_255 = lean_box(0);
 }
-x_257 = 1;
-if (lean_is_scalar(x_256)) {
- x_258 = lean_alloc_ctor(1, 4, 1);
+x_256 = 1;
+if (lean_is_scalar(x_255)) {
+ x_257 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_258 = x_256;
+ x_257 = x_255;
 }
-lean_ctor_set(x_258, 0, x_252);
-lean_ctor_set(x_258, 1, x_253);
-lean_ctor_set(x_258, 2, x_254);
-lean_ctor_set(x_258, 3, x_255);
-lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
-x_259 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_259, 0, x_251);
-lean_ctor_set(x_259, 1, x_36);
-lean_ctor_set(x_259, 2, x_37);
-lean_ctor_set(x_259, 3, x_38);
-lean_ctor_set_uint8(x_259, sizeof(void*)*4, x_257);
-lean_ctor_set(x_1, 3, x_259);
-lean_ctor_set(x_1, 2, x_250);
-lean_ctor_set(x_1, 1, x_249);
-lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_257, 0, x_217);
+lean_ctor_set(x_257, 1, x_249);
+lean_ctor_set(x_257, 2, x_250);
+lean_ctor_set(x_257, 3, x_251);
+lean_ctor_set_uint8(x_257, sizeof(void*)*4, x_256);
+x_258 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_258, 0, x_254);
+lean_ctor_set(x_258, 1, x_43);
+lean_ctor_set(x_258, 2, x_44);
+lean_ctor_set(x_258, 3, x_45);
+lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_256);
+x_259 = 0;
+lean_ctor_set(x_1, 3, x_258);
+lean_ctor_set(x_1, 2, x_253);
+lean_ctor_set(x_1, 1, x_252);
+lean_ctor_set(x_1, 0, x_257);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
 return x_1;
 }
 }
 else
 {
-lean_object* x_260; 
-x_260 = lean_ctor_get(x_186, 3);
-lean_inc(x_260);
-if (lean_obj_tag(x_260) == 0)
+uint8_t x_260; 
+x_260 = !lean_is_exclusive(x_216);
+if (x_260 == 0)
 {
-uint8_t x_261; 
-x_261 = !lean_is_exclusive(x_186);
-if (x_261 == 0)
-{
-lean_object* x_262; lean_object* x_263; uint8_t x_264; 
-x_262 = lean_ctor_get(x_186, 3);
+lean_object* x_261; lean_object* x_262; uint8_t x_263; uint8_t x_264; 
+x_261 = lean_ctor_get(x_216, 3);
+lean_dec(x_261);
+x_262 = lean_ctor_get(x_216, 0);
 lean_dec(x_262);
-x_263 = lean_ctor_get(x_186, 0);
-lean_dec(x_263);
-x_264 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_264);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+x_263 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_263);
+x_264 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_264);
 return x_1;
 }
 else
 {
-lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; 
-x_265 = lean_ctor_get(x_186, 1);
-x_266 = lean_ctor_get(x_186, 2);
+lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; uint8_t x_269; 
+x_265 = lean_ctor_get(x_216, 1);
+x_266 = lean_ctor_get(x_216, 2);
 lean_inc(x_266);
 lean_inc(x_265);
-lean_dec(x_186);
+lean_dec(x_216);
 x_267 = 0;
 x_268 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_268, 0, x_187);
+lean_ctor_set(x_268, 0, x_217);
 lean_ctor_set(x_268, 1, x_265);
 lean_ctor_set(x_268, 2, x_266);
-lean_ctor_set(x_268, 3, x_260);
+lean_ctor_set(x_268, 3, x_218);
 lean_ctor_set_uint8(x_268, sizeof(void*)*4, x_267);
+x_269 = 1;
 lean_ctor_set(x_1, 0, x_268);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_270; 
+x_270 = lean_ctor_get_uint8(x_217, sizeof(void*)*4);
+if (x_270 == 0)
+{
+uint8_t x_271; 
+x_271 = !lean_is_exclusive(x_216);
+if (x_271 == 0)
+{
+lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; uint8_t x_276; 
+x_272 = lean_ctor_get(x_216, 1);
+x_273 = lean_ctor_get(x_216, 2);
+x_274 = lean_ctor_get(x_216, 3);
+x_275 = lean_ctor_get(x_216, 0);
+lean_dec(x_275);
+x_276 = !lean_is_exclusive(x_217);
+if (x_276 == 0)
+{
+uint8_t x_277; uint8_t x_278; 
+x_277 = 1;
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_277);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_277);
+x_278 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_278);
+return x_1;
+}
+else
+{
+lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; uint8_t x_283; lean_object* x_284; uint8_t x_285; 
+x_279 = lean_ctor_get(x_217, 0);
+x_280 = lean_ctor_get(x_217, 1);
+x_281 = lean_ctor_get(x_217, 2);
+x_282 = lean_ctor_get(x_217, 3);
+lean_inc(x_282);
+lean_inc(x_281);
+lean_inc(x_280);
+lean_inc(x_279);
+lean_dec(x_217);
+x_283 = 1;
+x_284 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_284, 0, x_279);
+lean_ctor_set(x_284, 1, x_280);
+lean_ctor_set(x_284, 2, x_281);
+lean_ctor_set(x_284, 3, x_282);
+lean_ctor_set_uint8(x_284, sizeof(void*)*4, x_283);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_283);
+x_285 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_284);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_285);
 return x_1;
 }
 }
 else
 {
-uint8_t x_269; 
-x_269 = lean_ctor_get_uint8(x_260, sizeof(void*)*4);
-if (x_269 == 0)
-{
-uint8_t x_270; 
-lean_free_object(x_1);
-x_270 = !lean_is_exclusive(x_186);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; uint8_t x_275; 
-x_271 = lean_ctor_get(x_186, 1);
-x_272 = lean_ctor_get(x_186, 2);
-x_273 = lean_ctor_get(x_186, 3);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_186, 0);
-lean_dec(x_274);
-x_275 = !lean_is_exclusive(x_260);
-if (x_275 == 0)
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; uint8_t x_280; 
-x_276 = lean_ctor_get(x_260, 0);
-x_277 = lean_ctor_get(x_260, 1);
-x_278 = lean_ctor_get(x_260, 2);
-x_279 = lean_ctor_get(x_260, 3);
-lean_inc(x_187);
-lean_ctor_set(x_260, 3, x_276);
-lean_ctor_set(x_260, 2, x_272);
-lean_ctor_set(x_260, 1, x_271);
-lean_ctor_set(x_260, 0, x_187);
-x_280 = !lean_is_exclusive(x_187);
-if (x_280 == 0)
-{
-lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; 
-x_281 = lean_ctor_get(x_187, 3);
-lean_dec(x_281);
-x_282 = lean_ctor_get(x_187, 2);
-lean_dec(x_282);
-x_283 = lean_ctor_get(x_187, 1);
-lean_dec(x_283);
-x_284 = lean_ctor_get(x_187, 0);
-lean_dec(x_284);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-lean_ctor_set(x_187, 3, x_38);
-lean_ctor_set(x_187, 2, x_37);
-lean_ctor_set(x_187, 1, x_36);
-lean_ctor_set(x_187, 0, x_279);
-lean_ctor_set(x_186, 3, x_187);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-else
-{
-lean_object* x_285; 
-lean_dec(x_187);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-x_285 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_285, 0, x_279);
-lean_ctor_set(x_285, 1, x_36);
-lean_ctor_set(x_285, 2, x_37);
-lean_ctor_set(x_285, 3, x_38);
-lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_285);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-}
-else
-{
-lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; 
-x_286 = lean_ctor_get(x_260, 0);
-x_287 = lean_ctor_get(x_260, 1);
-x_288 = lean_ctor_get(x_260, 2);
-x_289 = lean_ctor_get(x_260, 3);
-lean_inc(x_289);
+lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; uint8_t x_294; lean_object* x_295; lean_object* x_296; uint8_t x_297; 
+x_286 = lean_ctor_get(x_216, 1);
+x_287 = lean_ctor_get(x_216, 2);
+x_288 = lean_ctor_get(x_216, 3);
 lean_inc(x_288);
 lean_inc(x_287);
 lean_inc(x_286);
-lean_dec(x_260);
-lean_inc(x_187);
-x_290 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_290, 0, x_187);
-lean_ctor_set(x_290, 1, x_271);
-lean_ctor_set(x_290, 2, x_272);
-lean_ctor_set(x_290, 3, x_286);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_291 = x_187;
+lean_dec(x_216);
+x_289 = lean_ctor_get(x_217, 0);
+lean_inc(x_289);
+x_290 = lean_ctor_get(x_217, 1);
+lean_inc(x_290);
+x_291 = lean_ctor_get(x_217, 2);
+lean_inc(x_291);
+x_292 = lean_ctor_get(x_217, 3);
+lean_inc(x_292);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_293 = x_217;
 } else {
- lean_dec_ref(x_187);
- x_291 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_293 = lean_box(0);
 }
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
+x_294 = 1;
+if (lean_is_scalar(x_293)) {
+ x_295 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_292 = x_291;
+ x_295 = x_293;
 }
-lean_ctor_set(x_292, 0, x_289);
-lean_ctor_set(x_292, 1, x_36);
-lean_ctor_set(x_292, 2, x_37);
-lean_ctor_set(x_292, 3, x_38);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_292);
-lean_ctor_set(x_186, 2, x_288);
-lean_ctor_set(x_186, 1, x_287);
-lean_ctor_set(x_186, 0, x_290);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
+lean_ctor_set(x_295, 0, x_289);
+lean_ctor_set(x_295, 1, x_290);
+lean_ctor_set(x_295, 2, x_291);
+lean_ctor_set(x_295, 3, x_292);
+lean_ctor_set_uint8(x_295, sizeof(void*)*4, x_294);
+x_296 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_296, 0, x_288);
+lean_ctor_set(x_296, 1, x_43);
+lean_ctor_set(x_296, 2, x_44);
+lean_ctor_set(x_296, 3, x_45);
+lean_ctor_set_uint8(x_296, sizeof(void*)*4, x_294);
+x_297 = 0;
+lean_ctor_set(x_1, 3, x_296);
+lean_ctor_set(x_1, 2, x_287);
+lean_ctor_set(x_1, 1, x_286);
+lean_ctor_set(x_1, 0, x_295);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_297);
+return x_1;
 }
 }
 else
 {
-lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; 
-x_293 = lean_ctor_get(x_186, 1);
-x_294 = lean_ctor_get(x_186, 2);
-lean_inc(x_294);
-lean_inc(x_293);
-lean_dec(x_186);
-x_295 = lean_ctor_get(x_260, 0);
-lean_inc(x_295);
-x_296 = lean_ctor_get(x_260, 1);
-lean_inc(x_296);
-x_297 = lean_ctor_get(x_260, 2);
-lean_inc(x_297);
-x_298 = lean_ctor_get(x_260, 3);
+lean_object* x_298; 
+x_298 = lean_ctor_get(x_216, 3);
 lean_inc(x_298);
-if (lean_is_exclusive(x_260)) {
- lean_ctor_release(x_260, 0);
- lean_ctor_release(x_260, 1);
- lean_ctor_release(x_260, 2);
- lean_ctor_release(x_260, 3);
- x_299 = x_260;
-} else {
- lean_dec_ref(x_260);
- x_299 = lean_box(0);
-}
-lean_inc(x_187);
-if (lean_is_scalar(x_299)) {
- x_300 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_300 = x_299;
-}
-lean_ctor_set(x_300, 0, x_187);
-lean_ctor_set(x_300, 1, x_293);
-lean_ctor_set(x_300, 2, x_294);
-lean_ctor_set(x_300, 3, x_295);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_301 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_301 = lean_box(0);
-}
-lean_ctor_set_uint8(x_300, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_301)) {
- x_302 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_302 = x_301;
-}
-lean_ctor_set(x_302, 0, x_298);
-lean_ctor_set(x_302, 1, x_36);
-lean_ctor_set(x_302, 2, x_37);
-lean_ctor_set(x_302, 3, x_38);
-lean_ctor_set_uint8(x_302, sizeof(void*)*4, x_235);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_300);
-lean_ctor_set(x_303, 1, x_296);
-lean_ctor_set(x_303, 2, x_297);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_269);
-return x_303;
-}
-}
-else
+if (lean_obj_tag(x_298) == 0)
 {
-uint8_t x_304; 
-x_304 = !lean_is_exclusive(x_186);
-if (x_304 == 0)
+uint8_t x_299; 
+x_299 = !lean_is_exclusive(x_216);
+if (x_299 == 0)
 {
-lean_object* x_305; lean_object* x_306; uint8_t x_307; 
-x_305 = lean_ctor_get(x_186, 3);
-lean_dec(x_305);
-x_306 = lean_ctor_get(x_186, 0);
-lean_dec(x_306);
-x_307 = !lean_is_exclusive(x_187);
-if (x_307 == 0)
-{
-uint8_t x_308; 
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_269);
-x_308 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_308);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_300; lean_object* x_301; uint8_t x_302; uint8_t x_303; 
+x_300 = lean_ctor_get(x_216, 3);
+lean_dec(x_300);
+x_301 = lean_ctor_get(x_216, 0);
+lean_dec(x_301);
+x_302 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_302);
+x_303 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_303);
 return x_1;
 }
 else
 {
-lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; uint8_t x_314; 
-x_309 = lean_ctor_get(x_187, 0);
-x_310 = lean_ctor_get(x_187, 1);
-x_311 = lean_ctor_get(x_187, 2);
-x_312 = lean_ctor_get(x_187, 3);
-lean_inc(x_312);
-lean_inc(x_311);
-lean_inc(x_310);
-lean_inc(x_309);
-lean_dec(x_187);
-x_313 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_313, 0, x_309);
-lean_ctor_set(x_313, 1, x_310);
-lean_ctor_set(x_313, 2, x_311);
-lean_ctor_set(x_313, 3, x_312);
-lean_ctor_set_uint8(x_313, sizeof(void*)*4, x_269);
-x_314 = 0;
-lean_ctor_set(x_186, 0, x_313);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_314);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_304; lean_object* x_305; uint8_t x_306; lean_object* x_307; uint8_t x_308; 
+x_304 = lean_ctor_get(x_216, 1);
+x_305 = lean_ctor_get(x_216, 2);
+lean_inc(x_305);
+lean_inc(x_304);
+lean_dec(x_216);
+x_306 = 0;
+x_307 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_307, 0, x_217);
+lean_ctor_set(x_307, 1, x_304);
+lean_ctor_set(x_307, 2, x_305);
+lean_ctor_set(x_307, 3, x_298);
+lean_ctor_set_uint8(x_307, sizeof(void*)*4, x_306);
+x_308 = 1;
+lean_ctor_set(x_1, 0, x_307);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_308);
 return x_1;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; 
-x_315 = lean_ctor_get(x_186, 1);
-x_316 = lean_ctor_get(x_186, 2);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_186);
-x_317 = lean_ctor_get(x_187, 0);
-lean_inc(x_317);
-x_318 = lean_ctor_get(x_187, 1);
-lean_inc(x_318);
-x_319 = lean_ctor_get(x_187, 2);
-lean_inc(x_319);
-x_320 = lean_ctor_get(x_187, 3);
-lean_inc(x_320);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_321 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_321 = lean_box(0);
-}
-if (lean_is_scalar(x_321)) {
- x_322 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_322 = x_321;
-}
-lean_ctor_set(x_322, 0, x_317);
-lean_ctor_set(x_322, 1, x_318);
-lean_ctor_set(x_322, 2, x_319);
-lean_ctor_set(x_322, 3, x_320);
-lean_ctor_set_uint8(x_322, sizeof(void*)*4, x_269);
-x_323 = 0;
-x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_322);
-lean_ctor_set(x_324, 1, x_315);
-lean_ctor_set(x_324, 2, x_316);
-lean_ctor_set(x_324, 3, x_260);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
-lean_ctor_set(x_1, 0, x_324);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_309; 
+x_309 = lean_ctor_get_uint8(x_298, sizeof(void*)*4);
+if (x_309 == 0)
+{
+uint8_t x_310; 
+lean_free_object(x_1);
+x_310 = !lean_is_exclusive(x_216);
+if (x_310 == 0)
+{
+lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; uint8_t x_315; 
+x_311 = lean_ctor_get(x_216, 1);
+x_312 = lean_ctor_get(x_216, 2);
+x_313 = lean_ctor_get(x_216, 3);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_216, 0);
+lean_dec(x_314);
+x_315 = !lean_is_exclusive(x_298);
+if (x_315 == 0)
+{
+lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; uint8_t x_320; uint8_t x_321; 
+x_316 = lean_ctor_get(x_298, 0);
+x_317 = lean_ctor_get(x_298, 1);
+x_318 = lean_ctor_get(x_298, 2);
+x_319 = lean_ctor_get(x_298, 3);
+x_320 = 1;
+lean_inc(x_217);
+lean_ctor_set(x_298, 3, x_316);
+lean_ctor_set(x_298, 2, x_312);
+lean_ctor_set(x_298, 1, x_311);
+lean_ctor_set(x_298, 0, x_217);
+x_321 = !lean_is_exclusive(x_217);
+if (x_321 == 0)
+{
+lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; uint8_t x_326; 
+x_322 = lean_ctor_get(x_217, 3);
+lean_dec(x_322);
+x_323 = lean_ctor_get(x_217, 2);
+lean_dec(x_323);
+x_324 = lean_ctor_get(x_217, 1);
+lean_dec(x_324);
+x_325 = lean_ctor_get(x_217, 0);
+lean_dec(x_325);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+lean_ctor_set(x_217, 3, x_45);
+lean_ctor_set(x_217, 2, x_44);
+lean_ctor_set(x_217, 1, x_43);
+lean_ctor_set(x_217, 0, x_319);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_320);
+x_326 = 0;
+lean_ctor_set(x_216, 3, x_217);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_326);
+return x_216;
 }
+else
+{
+lean_object* x_327; uint8_t x_328; 
+lean_dec(x_217);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+x_327 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_327, 0, x_319);
+lean_ctor_set(x_327, 1, x_43);
+lean_ctor_set(x_327, 2, x_44);
+lean_ctor_set(x_327, 3, x_45);
+lean_ctor_set_uint8(x_327, sizeof(void*)*4, x_320);
+x_328 = 0;
+lean_ctor_set(x_216, 3, x_327);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_328);
+return x_216;
 }
 }
 else
 {
-lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; uint32_t x_329; uint8_t x_330; 
-x_325 = lean_ctor_get(x_1, 0);
-x_326 = lean_ctor_get(x_1, 1);
-x_327 = lean_ctor_get(x_1, 2);
-x_328 = lean_ctor_get(x_1, 3);
-lean_inc(x_328);
-lean_inc(x_327);
-lean_inc(x_326);
-lean_inc(x_325);
-lean_dec(x_1);
-x_329 = lean_unbox_uint32(x_326);
-x_330 = x_2 < x_329;
-if (x_330 == 0)
-{
-uint32_t x_331; uint8_t x_332; 
-x_331 = lean_unbox_uint32(x_326);
-x_332 = x_331 < x_2;
-if (x_332 == 0)
-{
-lean_object* x_333; lean_object* x_334; 
-lean_dec(x_327);
-lean_dec(x_326);
-x_333 = lean_box_uint32(x_2);
+lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; uint8_t x_337; 
+x_329 = lean_ctor_get(x_298, 0);
+x_330 = lean_ctor_get(x_298, 1);
+x_331 = lean_ctor_get(x_298, 2);
+x_332 = lean_ctor_get(x_298, 3);
+lean_inc(x_332);
+lean_inc(x_331);
+lean_inc(x_330);
+lean_inc(x_329);
+lean_dec(x_298);
+x_333 = 1;
+lean_inc(x_217);
 x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_325);
-lean_ctor_set(x_334, 1, x_333);
-lean_ctor_set(x_334, 2, x_3);
-lean_ctor_set(x_334, 3, x_328);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_7);
-return x_334;
+lean_ctor_set(x_334, 0, x_217);
+lean_ctor_set(x_334, 1, x_311);
+lean_ctor_set(x_334, 2, x_312);
+lean_ctor_set(x_334, 3, x_329);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_335 = x_217;
+} else {
+ lean_dec_ref(x_217);
+ x_335 = lean_box(0);
+}
+lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
+if (lean_is_scalar(x_335)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_336 = x_335;
+}
+lean_ctor_set(x_336, 0, x_332);
+lean_ctor_set(x_336, 1, x_43);
+lean_ctor_set(x_336, 2, x_44);
+lean_ctor_set(x_336, 3, x_45);
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_333);
+x_337 = 0;
+lean_ctor_set(x_216, 3, x_336);
+lean_ctor_set(x_216, 2, x_331);
+lean_ctor_set(x_216, 1, x_330);
+lean_ctor_set(x_216, 0, x_334);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_337);
+return x_216;
+}
 }
 else
 {
-uint8_t x_335; 
-x_335 = l_Std_RBNode_isRed___rarg(x_328);
-if (x_335 == 0)
-{
-lean_object* x_336; lean_object* x_337; 
-x_336 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_328, x_2, x_3);
-x_337 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_337, 0, x_325);
-lean_ctor_set(x_337, 1, x_326);
-lean_ctor_set(x_337, 2, x_327);
-lean_ctor_set(x_337, 3, x_336);
-lean_ctor_set_uint8(x_337, sizeof(void*)*4, x_7);
-return x_337;
-}
-else
-{
-lean_object* x_338; lean_object* x_339; 
-x_338 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_328, x_2, x_3);
-x_339 = lean_ctor_get(x_338, 0);
+lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; uint8_t x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; uint8_t x_349; lean_object* x_350; 
+x_338 = lean_ctor_get(x_216, 1);
+x_339 = lean_ctor_get(x_216, 2);
 lean_inc(x_339);
-if (lean_obj_tag(x_339) == 0)
-{
-lean_object* x_340; 
-x_340 = lean_ctor_get(x_338, 3);
+lean_inc(x_338);
+lean_dec(x_216);
+x_340 = lean_ctor_get(x_298, 0);
 lean_inc(x_340);
-if (lean_obj_tag(x_340) == 0)
-{
-lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; uint8_t x_346; lean_object* x_347; 
-x_341 = lean_ctor_get(x_338, 1);
+x_341 = lean_ctor_get(x_298, 1);
 lean_inc(x_341);
-x_342 = lean_ctor_get(x_338, 2);
+x_342 = lean_ctor_get(x_298, 2);
 lean_inc(x_342);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_343 = x_338;
+x_343 = lean_ctor_get(x_298, 3);
+lean_inc(x_343);
+if (lean_is_exclusive(x_298)) {
+ lean_ctor_release(x_298, 0);
+ lean_ctor_release(x_298, 1);
+ lean_ctor_release(x_298, 2);
+ lean_ctor_release(x_298, 3);
+ x_344 = x_298;
 } else {
- lean_dec_ref(x_338);
- x_343 = lean_box(0);
+ lean_dec_ref(x_298);
+ x_344 = lean_box(0);
 }
-x_344 = 0;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
+x_345 = 1;
+lean_inc(x_217);
+if (lean_is_scalar(x_344)) {
+ x_346 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_345 = x_343;
+ x_346 = x_344;
 }
-lean_ctor_set(x_345, 0, x_340);
-lean_ctor_set(x_345, 1, x_341);
-lean_ctor_set(x_345, 2, x_342);
-lean_ctor_set(x_345, 3, x_340);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-x_346 = 1;
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_325);
-lean_ctor_set(x_347, 1, x_326);
-lean_ctor_set(x_347, 2, x_327);
-lean_ctor_set(x_347, 3, x_345);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_346);
-return x_347;
-}
-else
-{
-uint8_t x_348; 
-x_348 = lean_ctor_get_uint8(x_340, sizeof(void*)*4);
-if (x_348 == 0)
-{
-lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; uint8_t x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; 
-x_349 = lean_ctor_get(x_338, 1);
-lean_inc(x_349);
-x_350 = lean_ctor_get(x_338, 2);
-lean_inc(x_350);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_351 = x_338;
+lean_ctor_set(x_346, 0, x_217);
+lean_ctor_set(x_346, 1, x_338);
+lean_ctor_set(x_346, 2, x_339);
+lean_ctor_set(x_346, 3, x_340);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_347 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_351 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_347 = lean_box(0);
 }
-x_352 = lean_ctor_get(x_340, 0);
-lean_inc(x_352);
-x_353 = lean_ctor_get(x_340, 1);
-lean_inc(x_353);
-x_354 = lean_ctor_get(x_340, 2);
-lean_inc(x_354);
-x_355 = lean_ctor_get(x_340, 3);
-lean_inc(x_355);
-if (lean_is_exclusive(x_340)) {
- lean_ctor_release(x_340, 0);
- lean_ctor_release(x_340, 1);
- lean_ctor_release(x_340, 2);
- lean_ctor_release(x_340, 3);
- x_356 = x_340;
+lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_345);
+if (lean_is_scalar(x_347)) {
+ x_348 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_340);
- x_356 = lean_box(0);
-}
-x_357 = 1;
-if (lean_is_scalar(x_356)) {
- x_358 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_358 = x_356;
-}
-lean_ctor_set(x_358, 0, x_325);
-lean_ctor_set(x_358, 1, x_326);
-lean_ctor_set(x_358, 2, x_327);
-lean_ctor_set(x_358, 3, x_339);
-lean_ctor_set_uint8(x_358, sizeof(void*)*4, x_357);
-if (lean_is_scalar(x_351)) {
- x_359 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_359 = x_351;
-}
-lean_ctor_set(x_359, 0, x_352);
-lean_ctor_set(x_359, 1, x_353);
-lean_ctor_set(x_359, 2, x_354);
-lean_ctor_set(x_359, 3, x_355);
-lean_ctor_set_uint8(x_359, sizeof(void*)*4, x_357);
-x_360 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_360, 0, x_358);
-lean_ctor_set(x_360, 1, x_349);
-lean_ctor_set(x_360, 2, x_350);
-lean_ctor_set(x_360, 3, x_359);
-lean_ctor_set_uint8(x_360, sizeof(void*)*4, x_348);
-return x_360;
-}
-else
-{
-lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; 
-x_361 = lean_ctor_get(x_338, 1);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_338, 2);
-lean_inc(x_362);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_363 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_363 = lean_box(0);
-}
-x_364 = 0;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
-}
-lean_ctor_set(x_365, 0, x_339);
-lean_ctor_set(x_365, 1, x_361);
-lean_ctor_set(x_365, 2, x_362);
-lean_ctor_set(x_365, 3, x_340);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-x_366 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_366, 0, x_325);
-lean_ctor_set(x_366, 1, x_326);
-lean_ctor_set(x_366, 2, x_327);
-lean_ctor_set(x_366, 3, x_365);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_348);
-return x_366;
+ x_348 = x_347;
 }
+lean_ctor_set(x_348, 0, x_343);
+lean_ctor_set(x_348, 1, x_43);
+lean_ctor_set(x_348, 2, x_44);
+lean_ctor_set(x_348, 3, x_45);
+lean_ctor_set_uint8(x_348, sizeof(void*)*4, x_345);
+x_349 = 0;
+x_350 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_350, 0, x_346);
+lean_ctor_set(x_350, 1, x_341);
+lean_ctor_set(x_350, 2, x_342);
+lean_ctor_set(x_350, 3, x_348);
+lean_ctor_set_uint8(x_350, sizeof(void*)*4, x_349);
+return x_350;
 }
 }
 else
 {
-uint8_t x_367; 
-x_367 = lean_ctor_get_uint8(x_339, sizeof(void*)*4);
-if (x_367 == 0)
+uint8_t x_351; 
+x_351 = !lean_is_exclusive(x_216);
+if (x_351 == 0)
 {
-lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; uint8_t x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; 
-x_368 = lean_ctor_get(x_338, 1);
+lean_object* x_352; lean_object* x_353; uint8_t x_354; 
+x_352 = lean_ctor_get(x_216, 3);
+lean_dec(x_352);
+x_353 = lean_ctor_get(x_216, 0);
+lean_dec(x_353);
+x_354 = !lean_is_exclusive(x_217);
+if (x_354 == 0)
+{
+uint8_t x_355; uint8_t x_356; 
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_309);
+x_355 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_355);
+x_356 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_356);
+return x_1;
+}
+else
+{
+lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; uint8_t x_363; 
+x_357 = lean_ctor_get(x_217, 0);
+x_358 = lean_ctor_get(x_217, 1);
+x_359 = lean_ctor_get(x_217, 2);
+x_360 = lean_ctor_get(x_217, 3);
+lean_inc(x_360);
+lean_inc(x_359);
+lean_inc(x_358);
+lean_inc(x_357);
+lean_dec(x_217);
+x_361 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_361, 0, x_357);
+lean_ctor_set(x_361, 1, x_358);
+lean_ctor_set(x_361, 2, x_359);
+lean_ctor_set(x_361, 3, x_360);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_309);
+x_362 = 0;
+lean_ctor_set(x_216, 0, x_361);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_362);
+x_363 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_363);
+return x_1;
+}
+}
+else
+{
+lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; uint8_t x_374; 
+x_364 = lean_ctor_get(x_216, 1);
+x_365 = lean_ctor_get(x_216, 2);
+lean_inc(x_365);
+lean_inc(x_364);
+lean_dec(x_216);
+x_366 = lean_ctor_get(x_217, 0);
+lean_inc(x_366);
+x_367 = lean_ctor_get(x_217, 1);
+lean_inc(x_367);
+x_368 = lean_ctor_get(x_217, 2);
 lean_inc(x_368);
-x_369 = lean_ctor_get(x_338, 2);
+x_369 = lean_ctor_get(x_217, 3);
 lean_inc(x_369);
-x_370 = lean_ctor_get(x_338, 3);
-lean_inc(x_370);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_371 = x_338;
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_370 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_371 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_370 = lean_box(0);
 }
-x_372 = lean_ctor_get(x_339, 0);
-lean_inc(x_372);
-x_373 = lean_ctor_get(x_339, 1);
-lean_inc(x_373);
-x_374 = lean_ctor_get(x_339, 2);
-lean_inc(x_374);
-x_375 = lean_ctor_get(x_339, 3);
+if (lean_is_scalar(x_370)) {
+ x_371 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_371 = x_370;
+}
+lean_ctor_set(x_371, 0, x_366);
+lean_ctor_set(x_371, 1, x_367);
+lean_ctor_set(x_371, 2, x_368);
+lean_ctor_set(x_371, 3, x_369);
+lean_ctor_set_uint8(x_371, sizeof(void*)*4, x_309);
+x_372 = 0;
+x_373 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_373, 0, x_371);
+lean_ctor_set(x_373, 1, x_364);
+lean_ctor_set(x_373, 2, x_365);
+lean_ctor_set(x_373, 3, x_298);
+lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
+x_374 = 1;
+lean_ctor_set(x_1, 0, x_373);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_374);
+return x_1;
+}
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; uint32_t x_379; uint8_t x_380; 
+x_375 = lean_ctor_get(x_1, 0);
+x_376 = lean_ctor_get(x_1, 1);
+x_377 = lean_ctor_get(x_1, 2);
+x_378 = lean_ctor_get(x_1, 3);
+lean_inc(x_378);
+lean_inc(x_377);
+lean_inc(x_376);
 lean_inc(x_375);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_376 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_376 = lean_box(0);
-}
-x_377 = 1;
-if (lean_is_scalar(x_376)) {
- x_378 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_378 = x_376;
-}
-lean_ctor_set(x_378, 0, x_325);
-lean_ctor_set(x_378, 1, x_326);
-lean_ctor_set(x_378, 2, x_327);
-lean_ctor_set(x_378, 3, x_372);
-lean_ctor_set_uint8(x_378, sizeof(void*)*4, x_377);
-if (lean_is_scalar(x_371)) {
- x_379 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_379 = x_371;
-}
-lean_ctor_set(x_379, 0, x_375);
-lean_ctor_set(x_379, 1, x_368);
-lean_ctor_set(x_379, 2, x_369);
-lean_ctor_set(x_379, 3, x_370);
-lean_ctor_set_uint8(x_379, sizeof(void*)*4, x_377);
-x_380 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_380, 0, x_378);
-lean_ctor_set(x_380, 1, x_373);
-lean_ctor_set(x_380, 2, x_374);
-lean_ctor_set(x_380, 3, x_379);
-lean_ctor_set_uint8(x_380, sizeof(void*)*4, x_367);
-return x_380;
+lean_dec(x_1);
+x_379 = lean_unbox_uint32(x_376);
+x_380 = x_2 < x_379;
+if (x_380 == 0)
+{
+uint32_t x_381; uint8_t x_382; 
+x_381 = lean_unbox_uint32(x_376);
+x_382 = x_381 < x_2;
+if (x_382 == 0)
+{
+uint8_t x_383; lean_object* x_384; lean_object* x_385; 
+lean_dec(x_377);
+lean_dec(x_376);
+x_383 = 1;
+x_384 = lean_box_uint32(x_2);
+x_385 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_385, 0, x_375);
+lean_ctor_set(x_385, 1, x_384);
+lean_ctor_set(x_385, 2, x_3);
+lean_ctor_set(x_385, 3, x_378);
+lean_ctor_set_uint8(x_385, sizeof(void*)*4, x_383);
+return x_385;
 }
 else
 {
-lean_object* x_381; 
-x_381 = lean_ctor_get(x_338, 3);
-lean_inc(x_381);
-if (lean_obj_tag(x_381) == 0)
+uint8_t x_386; 
+x_386 = l_Std_RBNode_isRed___rarg(x_378);
+if (x_386 == 0)
 {
-lean_object* x_382; lean_object* x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; lean_object* x_387; 
-x_382 = lean_ctor_get(x_338, 1);
-lean_inc(x_382);
-x_383 = lean_ctor_get(x_338, 2);
-lean_inc(x_383);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_384 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_384 = lean_box(0);
-}
-x_385 = 0;
-if (lean_is_scalar(x_384)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_384;
-}
-lean_ctor_set(x_386, 0, x_339);
-lean_ctor_set(x_386, 1, x_382);
-lean_ctor_set(x_386, 2, x_383);
-lean_ctor_set(x_386, 3, x_381);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
-x_387 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_387, 0, x_325);
-lean_ctor_set(x_387, 1, x_326);
-lean_ctor_set(x_387, 2, x_327);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_367);
-return x_387;
+lean_object* x_387; uint8_t x_388; lean_object* x_389; 
+x_387 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_378, x_2, x_3);
+x_388 = 1;
+x_389 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_389, 0, x_375);
+lean_ctor_set(x_389, 1, x_376);
+lean_ctor_set(x_389, 2, x_377);
+lean_ctor_set(x_389, 3, x_387);
+lean_ctor_set_uint8(x_389, sizeof(void*)*4, x_388);
+return x_389;
 }
 else
 {
-uint8_t x_388; 
-x_388 = lean_ctor_get_uint8(x_381, sizeof(void*)*4);
-if (x_388 == 0)
+lean_object* x_390; lean_object* x_391; 
+x_390 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_378, x_2, x_3);
+x_391 = lean_ctor_get(x_390, 0);
+lean_inc(x_391);
+if (lean_obj_tag(x_391) == 0)
 {
-lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; 
-x_389 = lean_ctor_get(x_338, 1);
-lean_inc(x_389);
-x_390 = lean_ctor_get(x_338, 2);
-lean_inc(x_390);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_391 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_391 = lean_box(0);
-}
-x_392 = lean_ctor_get(x_381, 0);
+lean_object* x_392; 
+x_392 = lean_ctor_get(x_390, 3);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_381, 1);
+if (lean_obj_tag(x_392) == 0)
+{
+lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; uint8_t x_398; lean_object* x_399; 
+x_393 = lean_ctor_get(x_390, 1);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_381, 2);
+x_394 = lean_ctor_get(x_390, 2);
 lean_inc(x_394);
-x_395 = lean_ctor_get(x_381, 3);
-lean_inc(x_395);
-if (lean_is_exclusive(x_381)) {
- lean_ctor_release(x_381, 0);
- lean_ctor_release(x_381, 1);
- lean_ctor_release(x_381, 2);
- lean_ctor_release(x_381, 3);
- x_396 = x_381;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_395 = x_390;
 } else {
- lean_dec_ref(x_381);
- x_396 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_395 = lean_box(0);
 }
-lean_inc(x_339);
-if (lean_is_scalar(x_396)) {
+x_396 = 0;
+if (lean_is_scalar(x_395)) {
  x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_397 = x_396;
+ x_397 = x_395;
 }
-lean_ctor_set(x_397, 0, x_325);
-lean_ctor_set(x_397, 1, x_326);
-lean_ctor_set(x_397, 2, x_327);
-lean_ctor_set(x_397, 3, x_339);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_398 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_398 = lean_box(0);
-}
-lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_398)) {
- x_399 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_399 = x_398;
-}
-lean_ctor_set(x_399, 0, x_392);
-lean_ctor_set(x_399, 1, x_393);
-lean_ctor_set(x_399, 2, x_394);
-lean_ctor_set(x_399, 3, x_395);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_391)) {
- x_400 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_400 = x_391;
-}
-lean_ctor_set(x_400, 0, x_397);
-lean_ctor_set(x_400, 1, x_389);
-lean_ctor_set(x_400, 2, x_390);
-lean_ctor_set(x_400, 3, x_399);
-lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_388);
-return x_400;
+lean_ctor_set(x_397, 0, x_392);
+lean_ctor_set(x_397, 1, x_393);
+lean_ctor_set(x_397, 2, x_394);
+lean_ctor_set(x_397, 3, x_392);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
+x_398 = 1;
+x_399 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_399, 0, x_375);
+lean_ctor_set(x_399, 1, x_376);
+lean_ctor_set(x_399, 2, x_377);
+lean_ctor_set(x_399, 3, x_397);
+lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_398);
+return x_399;
 }
 else
 {
-lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; uint8_t x_410; lean_object* x_411; lean_object* x_412; 
-x_401 = lean_ctor_get(x_338, 1);
+uint8_t x_400; 
+x_400 = lean_ctor_get_uint8(x_392, sizeof(void*)*4);
+if (x_400 == 0)
+{
+lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; lean_object* x_411; uint8_t x_412; lean_object* x_413; 
+x_401 = lean_ctor_get(x_390, 1);
 lean_inc(x_401);
-x_402 = lean_ctor_get(x_338, 2);
+x_402 = lean_ctor_get(x_390, 2);
 lean_inc(x_402);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_403 = x_338;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_403 = x_390;
 } else {
- lean_dec_ref(x_338);
+ lean_dec_ref(x_390);
  x_403 = lean_box(0);
 }
-x_404 = lean_ctor_get(x_339, 0);
+x_404 = lean_ctor_get(x_392, 0);
 lean_inc(x_404);
-x_405 = lean_ctor_get(x_339, 1);
+x_405 = lean_ctor_get(x_392, 1);
 lean_inc(x_405);
-x_406 = lean_ctor_get(x_339, 2);
+x_406 = lean_ctor_get(x_392, 2);
 lean_inc(x_406);
-x_407 = lean_ctor_get(x_339, 3);
+x_407 = lean_ctor_get(x_392, 3);
 lean_inc(x_407);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_408 = x_339;
+if (lean_is_exclusive(x_392)) {
+ lean_ctor_release(x_392, 0);
+ lean_ctor_release(x_392, 1);
+ lean_ctor_release(x_392, 2);
+ lean_ctor_release(x_392, 3);
+ x_408 = x_392;
 } else {
- lean_dec_ref(x_339);
+ lean_dec_ref(x_392);
  x_408 = lean_box(0);
 }
+x_409 = 1;
 if (lean_is_scalar(x_408)) {
- x_409 = lean_alloc_ctor(1, 4, 1);
+ x_410 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_409 = x_408;
+ x_410 = x_408;
 }
-lean_ctor_set(x_409, 0, x_404);
-lean_ctor_set(x_409, 1, x_405);
-lean_ctor_set(x_409, 2, x_406);
-lean_ctor_set(x_409, 3, x_407);
-lean_ctor_set_uint8(x_409, sizeof(void*)*4, x_388);
-x_410 = 0;
+lean_ctor_set(x_410, 0, x_375);
+lean_ctor_set(x_410, 1, x_376);
+lean_ctor_set(x_410, 2, x_377);
+lean_ctor_set(x_410, 3, x_391);
+lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
 if (lean_is_scalar(x_403)) {
  x_411 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_411 = x_403;
 }
-lean_ctor_set(x_411, 0, x_409);
-lean_ctor_set(x_411, 1, x_401);
-lean_ctor_set(x_411, 2, x_402);
-lean_ctor_set(x_411, 3, x_381);
-lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_410);
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_325);
-lean_ctor_set(x_412, 1, x_326);
-lean_ctor_set(x_412, 2, x_327);
-lean_ctor_set(x_412, 3, x_411);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_388);
-return x_412;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_411, 0, x_404);
+lean_ctor_set(x_411, 1, x_405);
+lean_ctor_set(x_411, 2, x_406);
+lean_ctor_set(x_411, 3, x_407);
+lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_409);
+x_412 = 0;
+x_413 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_413, 0, x_410);
+lean_ctor_set(x_413, 1, x_401);
+lean_ctor_set(x_413, 2, x_402);
+lean_ctor_set(x_413, 3, x_411);
+lean_ctor_set_uint8(x_413, sizeof(void*)*4, x_412);
+return x_413;
 }
 else
 {
-uint8_t x_413; 
-x_413 = l_Std_RBNode_isRed___rarg(x_325);
-if (x_413 == 0)
-{
-lean_object* x_414; lean_object* x_415; 
-x_414 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_325, x_2, x_3);
-x_415 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_415, 0, x_414);
-lean_ctor_set(x_415, 1, x_326);
-lean_ctor_set(x_415, 2, x_327);
-lean_ctor_set(x_415, 3, x_328);
-lean_ctor_set_uint8(x_415, sizeof(void*)*4, x_7);
-return x_415;
-}
-else
-{
-lean_object* x_416; lean_object* x_417; 
-x_416 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_325, x_2, x_3);
-x_417 = lean_ctor_get(x_416, 0);
-lean_inc(x_417);
-if (lean_obj_tag(x_417) == 0)
-{
-lean_object* x_418; 
-x_418 = lean_ctor_get(x_416, 3);
-lean_inc(x_418);
-if (lean_obj_tag(x_418) == 0)
-{
-lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; uint8_t x_424; lean_object* x_425; 
-x_419 = lean_ctor_get(x_416, 1);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_416, 2);
-lean_inc(x_420);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_421 = x_416;
+lean_object* x_414; lean_object* x_415; lean_object* x_416; uint8_t x_417; lean_object* x_418; uint8_t x_419; lean_object* x_420; 
+x_414 = lean_ctor_get(x_390, 1);
+lean_inc(x_414);
+x_415 = lean_ctor_get(x_390, 2);
+lean_inc(x_415);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_416 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_421 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_416 = lean_box(0);
 }
-x_422 = 0;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+x_417 = 0;
+if (lean_is_scalar(x_416)) {
+ x_418 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_418 = x_416;
+}
+lean_ctor_set(x_418, 0, x_391);
+lean_ctor_set(x_418, 1, x_414);
+lean_ctor_set(x_418, 2, x_415);
+lean_ctor_set(x_418, 3, x_392);
+lean_ctor_set_uint8(x_418, sizeof(void*)*4, x_417);
+x_419 = 1;
+x_420 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_420, 0, x_375);
+lean_ctor_set(x_420, 1, x_376);
+lean_ctor_set(x_420, 2, x_377);
+lean_ctor_set(x_420, 3, x_418);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_419);
+return x_420;
+}
 }
-lean_ctor_set(x_423, 0, x_418);
-lean_ctor_set(x_423, 1, x_419);
-lean_ctor_set(x_423, 2, x_420);
-lean_ctor_set(x_423, 3, x_418);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-x_424 = 1;
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_326);
-lean_ctor_set(x_425, 2, x_327);
-lean_ctor_set(x_425, 3, x_328);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_424);
-return x_425;
 }
 else
 {
-uint8_t x_426; 
-x_426 = lean_ctor_get_uint8(x_418, sizeof(void*)*4);
-if (x_426 == 0)
+uint8_t x_421; 
+x_421 = lean_ctor_get_uint8(x_391, sizeof(void*)*4);
+if (x_421 == 0)
 {
-lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; uint8_t x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; 
-x_427 = lean_ctor_get(x_416, 1);
+lean_object* x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; uint8_t x_431; lean_object* x_432; lean_object* x_433; uint8_t x_434; lean_object* x_435; 
+x_422 = lean_ctor_get(x_390, 1);
+lean_inc(x_422);
+x_423 = lean_ctor_get(x_390, 2);
+lean_inc(x_423);
+x_424 = lean_ctor_get(x_390, 3);
+lean_inc(x_424);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_425 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_425 = lean_box(0);
+}
+x_426 = lean_ctor_get(x_391, 0);
+lean_inc(x_426);
+x_427 = lean_ctor_get(x_391, 1);
 lean_inc(x_427);
-x_428 = lean_ctor_get(x_416, 2);
+x_428 = lean_ctor_get(x_391, 2);
 lean_inc(x_428);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_429 = x_416;
+x_429 = lean_ctor_get(x_391, 3);
+lean_inc(x_429);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_430 = x_391;
 } else {
- lean_dec_ref(x_416);
- x_429 = lean_box(0);
+ lean_dec_ref(x_391);
+ x_430 = lean_box(0);
 }
-x_430 = lean_ctor_get(x_418, 0);
-lean_inc(x_430);
-x_431 = lean_ctor_get(x_418, 1);
-lean_inc(x_431);
-x_432 = lean_ctor_get(x_418, 2);
-lean_inc(x_432);
-x_433 = lean_ctor_get(x_418, 3);
-lean_inc(x_433);
-if (lean_is_exclusive(x_418)) {
- lean_ctor_release(x_418, 0);
- lean_ctor_release(x_418, 1);
- lean_ctor_release(x_418, 2);
- lean_ctor_release(x_418, 3);
- x_434 = x_418;
+x_431 = 1;
+if (lean_is_scalar(x_430)) {
+ x_432 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_418);
- x_434 = lean_box(0);
+ x_432 = x_430;
 }
-x_435 = 1;
-if (lean_is_scalar(x_434)) {
- x_436 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_432, 0, x_375);
+lean_ctor_set(x_432, 1, x_376);
+lean_ctor_set(x_432, 2, x_377);
+lean_ctor_set(x_432, 3, x_426);
+lean_ctor_set_uint8(x_432, sizeof(void*)*4, x_431);
+if (lean_is_scalar(x_425)) {
+ x_433 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_436 = x_434;
+ x_433 = x_425;
 }
-lean_ctor_set(x_436, 0, x_417);
-lean_ctor_set(x_436, 1, x_427);
-lean_ctor_set(x_436, 2, x_428);
-lean_ctor_set(x_436, 3, x_430);
-lean_ctor_set_uint8(x_436, sizeof(void*)*4, x_435);
-if (lean_is_scalar(x_429)) {
- x_437 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_437 = x_429;
-}
-lean_ctor_set(x_437, 0, x_433);
-lean_ctor_set(x_437, 1, x_326);
-lean_ctor_set(x_437, 2, x_327);
-lean_ctor_set(x_437, 3, x_328);
-lean_ctor_set_uint8(x_437, sizeof(void*)*4, x_435);
-x_438 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_438, 0, x_436);
-lean_ctor_set(x_438, 1, x_431);
-lean_ctor_set(x_438, 2, x_432);
-lean_ctor_set(x_438, 3, x_437);
-lean_ctor_set_uint8(x_438, sizeof(void*)*4, x_426);
-return x_438;
+lean_ctor_set(x_433, 0, x_429);
+lean_ctor_set(x_433, 1, x_422);
+lean_ctor_set(x_433, 2, x_423);
+lean_ctor_set(x_433, 3, x_424);
+lean_ctor_set_uint8(x_433, sizeof(void*)*4, x_431);
+x_434 = 0;
+x_435 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_435, 0, x_432);
+lean_ctor_set(x_435, 1, x_427);
+lean_ctor_set(x_435, 2, x_428);
+lean_ctor_set(x_435, 3, x_433);
+lean_ctor_set_uint8(x_435, sizeof(void*)*4, x_434);
+return x_435;
 }
 else
 {
-lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; 
-x_439 = lean_ctor_get(x_416, 1);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_416, 2);
-lean_inc(x_440);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_441 = x_416;
+lean_object* x_436; 
+x_436 = lean_ctor_get(x_390, 3);
+lean_inc(x_436);
+if (lean_obj_tag(x_436) == 0)
+{
+lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; 
+x_437 = lean_ctor_get(x_390, 1);
+lean_inc(x_437);
+x_438 = lean_ctor_get(x_390, 2);
+lean_inc(x_438);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_439 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_441 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_439 = lean_box(0);
 }
-x_442 = 0;
-if (lean_is_scalar(x_441)) {
- x_443 = lean_alloc_ctor(1, 4, 1);
+x_440 = 0;
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_441 = x_439;
 }
-lean_ctor_set(x_443, 0, x_417);
-lean_ctor_set(x_443, 1, x_439);
-lean_ctor_set(x_443, 2, x_440);
-lean_ctor_set(x_443, 3, x_418);
+lean_ctor_set(x_441, 0, x_391);
+lean_ctor_set(x_441, 1, x_437);
+lean_ctor_set(x_441, 2, x_438);
+lean_ctor_set(x_441, 3, x_436);
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+x_442 = 1;
+x_443 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_375);
+lean_ctor_set(x_443, 1, x_376);
+lean_ctor_set(x_443, 2, x_377);
+lean_ctor_set(x_443, 3, x_441);
 lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-x_444 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_444, 0, x_443);
-lean_ctor_set(x_444, 1, x_326);
-lean_ctor_set(x_444, 2, x_327);
-lean_ctor_set(x_444, 3, x_328);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_426);
-return x_444;
-}
-}
+return x_443;
 }
 else
 {
-uint8_t x_445; 
-x_445 = lean_ctor_get_uint8(x_417, sizeof(void*)*4);
-if (x_445 == 0)
+uint8_t x_444; 
+x_444 = lean_ctor_get_uint8(x_436, sizeof(void*)*4);
+if (x_444 == 0)
 {
-lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; 
-x_446 = lean_ctor_get(x_416, 1);
+lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; uint8_t x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_445 = lean_ctor_get(x_390, 1);
+lean_inc(x_445);
+x_446 = lean_ctor_get(x_390, 2);
 lean_inc(x_446);
-x_447 = lean_ctor_get(x_416, 2);
-lean_inc(x_447);
-x_448 = lean_ctor_get(x_416, 3);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_447 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_447 = lean_box(0);
+}
+x_448 = lean_ctor_get(x_436, 0);
 lean_inc(x_448);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_449 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_449 = lean_box(0);
-}
-x_450 = lean_ctor_get(x_417, 0);
+x_449 = lean_ctor_get(x_436, 1);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_436, 2);
 lean_inc(x_450);
-x_451 = lean_ctor_get(x_417, 1);
+x_451 = lean_ctor_get(x_436, 3);
 lean_inc(x_451);
-x_452 = lean_ctor_get(x_417, 2);
-lean_inc(x_452);
-x_453 = lean_ctor_get(x_417, 3);
-lean_inc(x_453);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_454 = x_417;
+if (lean_is_exclusive(x_436)) {
+ lean_ctor_release(x_436, 0);
+ lean_ctor_release(x_436, 1);
+ lean_ctor_release(x_436, 2);
+ lean_ctor_release(x_436, 3);
+ x_452 = x_436;
 } else {
- lean_dec_ref(x_417);
- x_454 = lean_box(0);
+ lean_dec_ref(x_436);
+ x_452 = lean_box(0);
 }
-x_455 = 1;
-if (lean_is_scalar(x_454)) {
+x_453 = 1;
+lean_inc(x_391);
+if (lean_is_scalar(x_452)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_452;
+}
+lean_ctor_set(x_454, 0, x_375);
+lean_ctor_set(x_454, 1, x_376);
+lean_ctor_set(x_454, 2, x_377);
+lean_ctor_set(x_454, 3, x_391);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_455 = x_391;
+} else {
+ lean_dec_ref(x_391);
+ x_455 = lean_box(0);
+}
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_453);
+if (lean_is_scalar(x_455)) {
  x_456 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_456 = x_454;
+ x_456 = x_455;
 }
-lean_ctor_set(x_456, 0, x_450);
-lean_ctor_set(x_456, 1, x_451);
-lean_ctor_set(x_456, 2, x_452);
-lean_ctor_set(x_456, 3, x_453);
-lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
-if (lean_is_scalar(x_449)) {
- x_457 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_456, 0, x_448);
+lean_ctor_set(x_456, 1, x_449);
+lean_ctor_set(x_456, 2, x_450);
+lean_ctor_set(x_456, 3, x_451);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_453);
+x_457 = 0;
+if (lean_is_scalar(x_447)) {
+ x_458 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_457 = x_449;
+ x_458 = x_447;
 }
-lean_ctor_set(x_457, 0, x_448);
-lean_ctor_set(x_457, 1, x_326);
-lean_ctor_set(x_457, 2, x_327);
-lean_ctor_set(x_457, 3, x_328);
-lean_ctor_set_uint8(x_457, sizeof(void*)*4, x_455);
-x_458 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_458, 0, x_456);
-lean_ctor_set(x_458, 1, x_446);
-lean_ctor_set(x_458, 2, x_447);
-lean_ctor_set(x_458, 3, x_457);
-lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_445);
+lean_ctor_set(x_458, 0, x_454);
+lean_ctor_set(x_458, 1, x_445);
+lean_ctor_set(x_458, 2, x_446);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
 return x_458;
 }
 else
 {
-lean_object* x_459; 
-x_459 = lean_ctor_get(x_416, 3);
+lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; uint8_t x_468; lean_object* x_469; uint8_t x_470; lean_object* x_471; 
+x_459 = lean_ctor_get(x_390, 1);
 lean_inc(x_459);
-if (lean_obj_tag(x_459) == 0)
-{
-lean_object* x_460; lean_object* x_461; lean_object* x_462; uint8_t x_463; lean_object* x_464; lean_object* x_465; 
-x_460 = lean_ctor_get(x_416, 1);
+x_460 = lean_ctor_get(x_390, 2);
 lean_inc(x_460);
-x_461 = lean_ctor_get(x_416, 2);
-lean_inc(x_461);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_462 = x_416;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_461 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_462 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_461 = lean_box(0);
 }
-x_463 = 0;
-if (lean_is_scalar(x_462)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
+x_462 = lean_ctor_get(x_391, 0);
+lean_inc(x_462);
+x_463 = lean_ctor_get(x_391, 1);
+lean_inc(x_463);
+x_464 = lean_ctor_get(x_391, 2);
+lean_inc(x_464);
+x_465 = lean_ctor_get(x_391, 3);
+lean_inc(x_465);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_466 = x_391;
 } else {
- x_464 = x_462;
+ lean_dec_ref(x_391);
+ x_466 = lean_box(0);
+}
+if (lean_is_scalar(x_466)) {
+ x_467 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_467 = x_466;
+}
+lean_ctor_set(x_467, 0, x_462);
+lean_ctor_set(x_467, 1, x_463);
+lean_ctor_set(x_467, 2, x_464);
+lean_ctor_set(x_467, 3, x_465);
+lean_ctor_set_uint8(x_467, sizeof(void*)*4, x_444);
+x_468 = 0;
+if (lean_is_scalar(x_461)) {
+ x_469 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_469 = x_461;
+}
+lean_ctor_set(x_469, 0, x_467);
+lean_ctor_set(x_469, 1, x_459);
+lean_ctor_set(x_469, 2, x_460);
+lean_ctor_set(x_469, 3, x_436);
+lean_ctor_set_uint8(x_469, sizeof(void*)*4, x_468);
+x_470 = 1;
+x_471 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_471, 0, x_375);
+lean_ctor_set(x_471, 1, x_376);
+lean_ctor_set(x_471, 2, x_377);
+lean_ctor_set(x_471, 3, x_469);
+lean_ctor_set_uint8(x_471, sizeof(void*)*4, x_470);
+return x_471;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_464, 0, x_417);
-lean_ctor_set(x_464, 1, x_460);
-lean_ctor_set(x_464, 2, x_461);
-lean_ctor_set(x_464, 3, x_459);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_463);
-x_465 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_465, 0, x_464);
-lean_ctor_set(x_465, 1, x_326);
-lean_ctor_set(x_465, 2, x_327);
-lean_ctor_set(x_465, 3, x_328);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_445);
-return x_465;
 }
 else
 {
-uint8_t x_466; 
-x_466 = lean_ctor_get_uint8(x_459, sizeof(void*)*4);
-if (x_466 == 0)
+uint8_t x_472; 
+x_472 = l_Std_RBNode_isRed___rarg(x_375);
+if (x_472 == 0)
 {
-lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; 
-x_467 = lean_ctor_get(x_416, 1);
-lean_inc(x_467);
-x_468 = lean_ctor_get(x_416, 2);
-lean_inc(x_468);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_469 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_469 = lean_box(0);
-}
-x_470 = lean_ctor_get(x_459, 0);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_459, 1);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_459, 2);
-lean_inc(x_472);
-x_473 = lean_ctor_get(x_459, 3);
-lean_inc(x_473);
-if (lean_is_exclusive(x_459)) {
- lean_ctor_release(x_459, 0);
- lean_ctor_release(x_459, 1);
- lean_ctor_release(x_459, 2);
- lean_ctor_release(x_459, 3);
- x_474 = x_459;
-} else {
- lean_dec_ref(x_459);
- x_474 = lean_box(0);
-}
-lean_inc(x_417);
-if (lean_is_scalar(x_474)) {
- x_475 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_475 = x_474;
-}
-lean_ctor_set(x_475, 0, x_417);
-lean_ctor_set(x_475, 1, x_467);
-lean_ctor_set(x_475, 2, x_468);
-lean_ctor_set(x_475, 3, x_470);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_476 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_476 = lean_box(0);
-}
-lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_476)) {
- x_477 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_477 = x_476;
-}
-lean_ctor_set(x_477, 0, x_473);
-lean_ctor_set(x_477, 1, x_326);
-lean_ctor_set(x_477, 2, x_327);
-lean_ctor_set(x_477, 3, x_328);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_469)) {
- x_478 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_478 = x_469;
-}
-lean_ctor_set(x_478, 0, x_475);
-lean_ctor_set(x_478, 1, x_471);
-lean_ctor_set(x_478, 2, x_472);
-lean_ctor_set(x_478, 3, x_477);
-lean_ctor_set_uint8(x_478, sizeof(void*)*4, x_466);
-return x_478;
+lean_object* x_473; uint8_t x_474; lean_object* x_475; 
+x_473 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_375, x_2, x_3);
+x_474 = 1;
+x_475 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_475, 0, x_473);
+lean_ctor_set(x_475, 1, x_376);
+lean_ctor_set(x_475, 2, x_377);
+lean_ctor_set(x_475, 3, x_378);
+lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_474);
+return x_475;
 }
 else
 {
-lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; uint8_t x_488; lean_object* x_489; lean_object* x_490; 
-x_479 = lean_ctor_get(x_416, 1);
+lean_object* x_476; lean_object* x_477; 
+x_476 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_375, x_2, x_3);
+x_477 = lean_ctor_get(x_476, 0);
+lean_inc(x_477);
+if (lean_obj_tag(x_477) == 0)
+{
+lean_object* x_478; 
+x_478 = lean_ctor_get(x_476, 3);
+lean_inc(x_478);
+if (lean_obj_tag(x_478) == 0)
+{
+lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; uint8_t x_484; lean_object* x_485; 
+x_479 = lean_ctor_get(x_476, 1);
 lean_inc(x_479);
-x_480 = lean_ctor_get(x_416, 2);
+x_480 = lean_ctor_get(x_476, 2);
 lean_inc(x_480);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_481 = x_416;
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_481 = x_476;
 } else {
- lean_dec_ref(x_416);
+ lean_dec_ref(x_476);
  x_481 = lean_box(0);
 }
-x_482 = lean_ctor_get(x_417, 0);
-lean_inc(x_482);
-x_483 = lean_ctor_get(x_417, 1);
-lean_inc(x_483);
-x_484 = lean_ctor_get(x_417, 2);
-lean_inc(x_484);
-x_485 = lean_ctor_get(x_417, 3);
-lean_inc(x_485);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_486 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_486 = lean_box(0);
-}
-if (lean_is_scalar(x_486)) {
- x_487 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_487 = x_486;
-}
-lean_ctor_set(x_487, 0, x_482);
-lean_ctor_set(x_487, 1, x_483);
-lean_ctor_set(x_487, 2, x_484);
-lean_ctor_set(x_487, 3, x_485);
-lean_ctor_set_uint8(x_487, sizeof(void*)*4, x_466);
-x_488 = 0;
+x_482 = 0;
 if (lean_is_scalar(x_481)) {
- x_489 = lean_alloc_ctor(1, 4, 1);
+ x_483 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_489 = x_481;
+ x_483 = x_481;
 }
-lean_ctor_set(x_489, 0, x_487);
-lean_ctor_set(x_489, 1, x_479);
-lean_ctor_set(x_489, 2, x_480);
-lean_ctor_set(x_489, 3, x_459);
-lean_ctor_set_uint8(x_489, sizeof(void*)*4, x_488);
-x_490 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_490, 0, x_489);
-lean_ctor_set(x_490, 1, x_326);
-lean_ctor_set(x_490, 2, x_327);
-lean_ctor_set(x_490, 3, x_328);
-lean_ctor_set_uint8(x_490, sizeof(void*)*4, x_466);
-return x_490;
+lean_ctor_set(x_483, 0, x_478);
+lean_ctor_set(x_483, 1, x_479);
+lean_ctor_set(x_483, 2, x_480);
+lean_ctor_set(x_483, 3, x_478);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+x_484 = 1;
+x_485 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_485, 0, x_483);
+lean_ctor_set(x_485, 1, x_376);
+lean_ctor_set(x_485, 2, x_377);
+lean_ctor_set(x_485, 3, x_378);
+lean_ctor_set_uint8(x_485, sizeof(void*)*4, x_484);
+return x_485;
+}
+else
+{
+uint8_t x_486; 
+x_486 = lean_ctor_get_uint8(x_478, sizeof(void*)*4);
+if (x_486 == 0)
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; uint8_t x_495; lean_object* x_496; lean_object* x_497; uint8_t x_498; lean_object* x_499; 
+x_487 = lean_ctor_get(x_476, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_476, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_489 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_489 = lean_box(0);
+}
+x_490 = lean_ctor_get(x_478, 0);
+lean_inc(x_490);
+x_491 = lean_ctor_get(x_478, 1);
+lean_inc(x_491);
+x_492 = lean_ctor_get(x_478, 2);
+lean_inc(x_492);
+x_493 = lean_ctor_get(x_478, 3);
+lean_inc(x_493);
+if (lean_is_exclusive(x_478)) {
+ lean_ctor_release(x_478, 0);
+ lean_ctor_release(x_478, 1);
+ lean_ctor_release(x_478, 2);
+ lean_ctor_release(x_478, 3);
+ x_494 = x_478;
+} else {
+ lean_dec_ref(x_478);
+ x_494 = lean_box(0);
+}
+x_495 = 1;
+if (lean_is_scalar(x_494)) {
+ x_496 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_496 = x_494;
+}
+lean_ctor_set(x_496, 0, x_477);
+lean_ctor_set(x_496, 1, x_487);
+lean_ctor_set(x_496, 2, x_488);
+lean_ctor_set(x_496, 3, x_490);
+lean_ctor_set_uint8(x_496, sizeof(void*)*4, x_495);
+if (lean_is_scalar(x_489)) {
+ x_497 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_497 = x_489;
+}
+lean_ctor_set(x_497, 0, x_493);
+lean_ctor_set(x_497, 1, x_376);
+lean_ctor_set(x_497, 2, x_377);
+lean_ctor_set(x_497, 3, x_378);
+lean_ctor_set_uint8(x_497, sizeof(void*)*4, x_495);
+x_498 = 0;
+x_499 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_499, 0, x_496);
+lean_ctor_set(x_499, 1, x_491);
+lean_ctor_set(x_499, 2, x_492);
+lean_ctor_set(x_499, 3, x_497);
+lean_ctor_set_uint8(x_499, sizeof(void*)*4, x_498);
+return x_499;
+}
+else
+{
+lean_object* x_500; lean_object* x_501; lean_object* x_502; uint8_t x_503; lean_object* x_504; uint8_t x_505; lean_object* x_506; 
+x_500 = lean_ctor_get(x_476, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_476, 2);
+lean_inc(x_501);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_502 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_502 = lean_box(0);
+}
+x_503 = 0;
+if (lean_is_scalar(x_502)) {
+ x_504 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_504 = x_502;
+}
+lean_ctor_set(x_504, 0, x_477);
+lean_ctor_set(x_504, 1, x_500);
+lean_ctor_set(x_504, 2, x_501);
+lean_ctor_set(x_504, 3, x_478);
+lean_ctor_set_uint8(x_504, sizeof(void*)*4, x_503);
+x_505 = 1;
+x_506 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_506, 0, x_504);
+lean_ctor_set(x_506, 1, x_376);
+lean_ctor_set(x_506, 2, x_377);
+lean_ctor_set(x_506, 3, x_378);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_505);
+return x_506;
+}
+}
+}
+else
+{
+uint8_t x_507; 
+x_507 = lean_ctor_get_uint8(x_477, sizeof(void*)*4);
+if (x_507 == 0)
+{
+lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; lean_object* x_516; uint8_t x_517; lean_object* x_518; lean_object* x_519; uint8_t x_520; lean_object* x_521; 
+x_508 = lean_ctor_get(x_476, 1);
+lean_inc(x_508);
+x_509 = lean_ctor_get(x_476, 2);
+lean_inc(x_509);
+x_510 = lean_ctor_get(x_476, 3);
+lean_inc(x_510);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_511 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_511 = lean_box(0);
+}
+x_512 = lean_ctor_get(x_477, 0);
+lean_inc(x_512);
+x_513 = lean_ctor_get(x_477, 1);
+lean_inc(x_513);
+x_514 = lean_ctor_get(x_477, 2);
+lean_inc(x_514);
+x_515 = lean_ctor_get(x_477, 3);
+lean_inc(x_515);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_516 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_516 = lean_box(0);
+}
+x_517 = 1;
+if (lean_is_scalar(x_516)) {
+ x_518 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_518 = x_516;
+}
+lean_ctor_set(x_518, 0, x_512);
+lean_ctor_set(x_518, 1, x_513);
+lean_ctor_set(x_518, 2, x_514);
+lean_ctor_set(x_518, 3, x_515);
+lean_ctor_set_uint8(x_518, sizeof(void*)*4, x_517);
+if (lean_is_scalar(x_511)) {
+ x_519 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_519 = x_511;
+}
+lean_ctor_set(x_519, 0, x_510);
+lean_ctor_set(x_519, 1, x_376);
+lean_ctor_set(x_519, 2, x_377);
+lean_ctor_set(x_519, 3, x_378);
+lean_ctor_set_uint8(x_519, sizeof(void*)*4, x_517);
+x_520 = 0;
+x_521 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_521, 0, x_518);
+lean_ctor_set(x_521, 1, x_508);
+lean_ctor_set(x_521, 2, x_509);
+lean_ctor_set(x_521, 3, x_519);
+lean_ctor_set_uint8(x_521, sizeof(void*)*4, x_520);
+return x_521;
+}
+else
+{
+lean_object* x_522; 
+x_522 = lean_ctor_get(x_476, 3);
+lean_inc(x_522);
+if (lean_obj_tag(x_522) == 0)
+{
+lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; uint8_t x_528; lean_object* x_529; 
+x_523 = lean_ctor_get(x_476, 1);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_476, 2);
+lean_inc(x_524);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_525 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_525 = lean_box(0);
+}
+x_526 = 0;
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_477);
+lean_ctor_set(x_527, 1, x_523);
+lean_ctor_set(x_527, 2, x_524);
+lean_ctor_set(x_527, 3, x_522);
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+x_528 = 1;
+x_529 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_529, 0, x_527);
+lean_ctor_set(x_529, 1, x_376);
+lean_ctor_set(x_529, 2, x_377);
+lean_ctor_set(x_529, 3, x_378);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_528);
+return x_529;
+}
+else
+{
+uint8_t x_530; 
+x_530 = lean_ctor_get_uint8(x_522, sizeof(void*)*4);
+if (x_530 == 0)
+{
+lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; uint8_t x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_531 = lean_ctor_get(x_476, 1);
+lean_inc(x_531);
+x_532 = lean_ctor_get(x_476, 2);
+lean_inc(x_532);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_533 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_533 = lean_box(0);
+}
+x_534 = lean_ctor_get(x_522, 0);
+lean_inc(x_534);
+x_535 = lean_ctor_get(x_522, 1);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_522, 2);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_522, 3);
+lean_inc(x_537);
+if (lean_is_exclusive(x_522)) {
+ lean_ctor_release(x_522, 0);
+ lean_ctor_release(x_522, 1);
+ lean_ctor_release(x_522, 2);
+ lean_ctor_release(x_522, 3);
+ x_538 = x_522;
+} else {
+ lean_dec_ref(x_522);
+ x_538 = lean_box(0);
+}
+x_539 = 1;
+lean_inc(x_477);
+if (lean_is_scalar(x_538)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_538;
+}
+lean_ctor_set(x_540, 0, x_477);
+lean_ctor_set(x_540, 1, x_531);
+lean_ctor_set(x_540, 2, x_532);
+lean_ctor_set(x_540, 3, x_534);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_541 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_541 = lean_box(0);
+}
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_539);
+if (lean_is_scalar(x_541)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_541;
+}
+lean_ctor_set(x_542, 0, x_537);
+lean_ctor_set(x_542, 1, x_376);
+lean_ctor_set(x_542, 2, x_377);
+lean_ctor_set(x_542, 3, x_378);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_539);
+x_543 = 0;
+if (lean_is_scalar(x_533)) {
+ x_544 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_544 = x_533;
+}
+lean_ctor_set(x_544, 0, x_540);
+lean_ctor_set(x_544, 1, x_535);
+lean_ctor_set(x_544, 2, x_536);
+lean_ctor_set(x_544, 3, x_542);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
+}
+else
+{
+lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; uint8_t x_554; lean_object* x_555; uint8_t x_556; lean_object* x_557; 
+x_545 = lean_ctor_get(x_476, 1);
+lean_inc(x_545);
+x_546 = lean_ctor_get(x_476, 2);
+lean_inc(x_546);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_547 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_547 = lean_box(0);
+}
+x_548 = lean_ctor_get(x_477, 0);
+lean_inc(x_548);
+x_549 = lean_ctor_get(x_477, 1);
+lean_inc(x_549);
+x_550 = lean_ctor_get(x_477, 2);
+lean_inc(x_550);
+x_551 = lean_ctor_get(x_477, 3);
+lean_inc(x_551);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_552 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_552 = lean_box(0);
+}
+if (lean_is_scalar(x_552)) {
+ x_553 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_553 = x_552;
+}
+lean_ctor_set(x_553, 0, x_548);
+lean_ctor_set(x_553, 1, x_549);
+lean_ctor_set(x_553, 2, x_550);
+lean_ctor_set(x_553, 3, x_551);
+lean_ctor_set_uint8(x_553, sizeof(void*)*4, x_530);
+x_554 = 0;
+if (lean_is_scalar(x_547)) {
+ x_555 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_555 = x_547;
+}
+lean_ctor_set(x_555, 0, x_553);
+lean_ctor_set(x_555, 1, x_545);
+lean_ctor_set(x_555, 2, x_546);
+lean_ctor_set(x_555, 3, x_522);
+lean_ctor_set_uint8(x_555, sizeof(void*)*4, x_554);
+x_556 = 1;
+x_557 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_557, 0, x_555);
+lean_ctor_set(x_557, 1, x_376);
+lean_ctor_set(x_557, 2, x_377);
+lean_ctor_set(x_557, 3, x_378);
+lean_ctor_set_uint8(x_557, sizeof(void*)*4, x_556);
+return x_557;
 }
 }
 }
@@ -7532,2403 +7876,2478 @@ return x_490;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; lean_object* x_6; 
-x_4 = 0;
-x_5 = lean_box_uint32(x_2);
-x_6 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_6, 0, x_1);
-lean_ctor_set(x_6, 1, x_5);
-lean_ctor_set(x_6, 2, x_3);
-lean_ctor_set(x_6, 3, x_1);
-lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_4);
-return x_6;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; lean_object* x_7; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_box_uint32(x_2);
+x_7 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_7, 0, x_4);
+lean_ctor_set(x_7, 1, x_6);
+lean_ctor_set(x_7, 2, x_3);
+lean_ctor_set(x_7, 3, x_4);
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_5);
+return x_7;
 }
 else
 {
-uint8_t x_7; 
-x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_7 == 0)
-{
 uint8_t x_8; 
-x_8 = !lean_is_exclusive(x_1);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_8 == 0)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint32_t x_13; uint8_t x_14; 
-x_9 = lean_ctor_get(x_1, 0);
-x_10 = lean_ctor_get(x_1, 1);
-x_11 = lean_ctor_get(x_1, 2);
-x_12 = lean_ctor_get(x_1, 3);
-x_13 = lean_unbox_uint32(x_10);
-x_14 = x_2 < x_13;
-if (x_14 == 0)
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_1);
+if (x_9 == 0)
 {
-uint32_t x_15; uint8_t x_16; 
-x_15 = lean_unbox_uint32(x_10);
-x_16 = x_15 < x_2;
-if (x_16 == 0)
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint32_t x_14; uint8_t x_15; 
+x_10 = lean_ctor_get(x_1, 0);
+x_11 = lean_ctor_get(x_1, 1);
+x_12 = lean_ctor_get(x_1, 2);
+x_13 = lean_ctor_get(x_1, 3);
+x_14 = lean_unbox_uint32(x_11);
+x_15 = x_2 < x_14;
+if (x_15 == 0)
 {
-lean_object* x_17; 
+uint32_t x_16; uint8_t x_17; 
+x_16 = lean_unbox_uint32(x_11);
+x_17 = x_16 < x_2;
+if (x_17 == 0)
+{
+uint8_t x_18; lean_object* x_19; 
+lean_dec(x_12);
 lean_dec(x_11);
-lean_dec(x_10);
-x_17 = lean_box_uint32(x_2);
+x_18 = 0;
+x_19 = lean_box_uint32(x_2);
 lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_17);
+lean_ctor_set(x_1, 1, x_19);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_18);
 return x_1;
 }
 else
 {
-lean_object* x_18; 
-x_18 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_12, x_2, x_3);
-lean_ctor_set(x_1, 3, x_18);
+lean_object* x_20; uint8_t x_21; 
+x_20 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_13, x_2, x_3);
+x_21 = 0;
+lean_ctor_set(x_1, 3, x_20);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_21);
 return x_1;
 }
 }
 else
 {
-lean_object* x_19; 
-x_19 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_9, x_2, x_3);
-lean_ctor_set(x_1, 0, x_19);
+lean_object* x_22; uint8_t x_23; 
+x_22 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_10, x_2, x_3);
+x_23 = 0;
+lean_ctor_set(x_1, 0, x_22);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_23);
 return x_1;
 }
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint32_t x_24; uint8_t x_25; 
-x_20 = lean_ctor_get(x_1, 0);
-x_21 = lean_ctor_get(x_1, 1);
-x_22 = lean_ctor_get(x_1, 2);
-x_23 = lean_ctor_get(x_1, 3);
-lean_inc(x_23);
-lean_inc(x_22);
-lean_inc(x_21);
-lean_inc(x_20);
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint32_t x_28; uint8_t x_29; 
+x_24 = lean_ctor_get(x_1, 0);
+x_25 = lean_ctor_get(x_1, 1);
+x_26 = lean_ctor_get(x_1, 2);
+x_27 = lean_ctor_get(x_1, 3);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_inc(x_24);
 lean_dec(x_1);
-x_24 = lean_unbox_uint32(x_21);
-x_25 = x_2 < x_24;
-if (x_25 == 0)
+x_28 = lean_unbox_uint32(x_25);
+x_29 = x_2 < x_28;
+if (x_29 == 0)
 {
-uint32_t x_26; uint8_t x_27; 
-x_26 = lean_unbox_uint32(x_21);
-x_27 = x_26 < x_2;
-if (x_27 == 0)
+uint32_t x_30; uint8_t x_31; 
+x_30 = lean_unbox_uint32(x_25);
+x_31 = x_30 < x_2;
+if (x_31 == 0)
 {
-lean_object* x_28; lean_object* x_29; 
-lean_dec(x_22);
-lean_dec(x_21);
-x_28 = lean_box_uint32(x_2);
-x_29 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_29, 0, x_20);
-lean_ctor_set(x_29, 1, x_28);
-lean_ctor_set(x_29, 2, x_3);
-lean_ctor_set(x_29, 3, x_23);
-lean_ctor_set_uint8(x_29, sizeof(void*)*4, x_7);
-return x_29;
+uint8_t x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_26);
+lean_dec(x_25);
+x_32 = 0;
+x_33 = lean_box_uint32(x_2);
+x_34 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_34, 0, x_24);
+lean_ctor_set(x_34, 1, x_33);
+lean_ctor_set(x_34, 2, x_3);
+lean_ctor_set(x_34, 3, x_27);
+lean_ctor_set_uint8(x_34, sizeof(void*)*4, x_32);
+return x_34;
 }
 else
 {
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_23, x_2, x_3);
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_20);
-lean_ctor_set(x_31, 1, x_21);
-lean_ctor_set(x_31, 2, x_22);
-lean_ctor_set(x_31, 3, x_30);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_7);
-return x_31;
+lean_object* x_35; uint8_t x_36; lean_object* x_37; 
+x_35 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_27, x_2, x_3);
+x_36 = 0;
+x_37 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_37, 0, x_24);
+lean_ctor_set(x_37, 1, x_25);
+lean_ctor_set(x_37, 2, x_26);
+lean_ctor_set(x_37, 3, x_35);
+lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
+return x_37;
 }
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_20, x_2, x_3);
-x_33 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_21);
-lean_ctor_set(x_33, 2, x_22);
-lean_ctor_set(x_33, 3, x_23);
-lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_7);
-return x_33;
+lean_object* x_38; uint8_t x_39; lean_object* x_40; 
+x_38 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_24, x_2, x_3);
+x_39 = 0;
+x_40 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_40, 0, x_38);
+lean_ctor_set(x_40, 1, x_25);
+lean_ctor_set(x_40, 2, x_26);
+lean_ctor_set(x_40, 3, x_27);
+lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_39);
+return x_40;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = !lean_is_exclusive(x_1);
-if (x_34 == 0)
+uint8_t x_41; 
+x_41 = !lean_is_exclusive(x_1);
+if (x_41 == 0)
 {
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint32_t x_39; uint8_t x_40; 
-x_35 = lean_ctor_get(x_1, 0);
-x_36 = lean_ctor_get(x_1, 1);
-x_37 = lean_ctor_get(x_1, 2);
-x_38 = lean_ctor_get(x_1, 3);
-x_39 = lean_unbox_uint32(x_36);
-x_40 = x_2 < x_39;
-if (x_40 == 0)
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; uint32_t x_46; uint8_t x_47; 
+x_42 = lean_ctor_get(x_1, 0);
+x_43 = lean_ctor_get(x_1, 1);
+x_44 = lean_ctor_get(x_1, 2);
+x_45 = lean_ctor_get(x_1, 3);
+x_46 = lean_unbox_uint32(x_43);
+x_47 = x_2 < x_46;
+if (x_47 == 0)
 {
-uint32_t x_41; uint8_t x_42; 
-x_41 = lean_unbox_uint32(x_36);
-x_42 = x_41 < x_2;
-if (x_42 == 0)
-{
-lean_object* x_43; 
-lean_dec(x_37);
-lean_dec(x_36);
-x_43 = lean_box_uint32(x_2);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_43);
-return x_1;
-}
-else
-{
-uint8_t x_44; 
-x_44 = l_Std_RBNode_isRed___rarg(x_38);
-if (x_44 == 0)
-{
-lean_object* x_45; 
-x_45 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_38, x_2, x_3);
-lean_ctor_set(x_1, 3, x_45);
-return x_1;
-}
-else
-{
-lean_object* x_46; lean_object* x_47; 
-x_46 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_38, x_2, x_3);
-x_47 = lean_ctor_get(x_46, 0);
-lean_inc(x_47);
-if (lean_obj_tag(x_47) == 0)
-{
-lean_object* x_48; 
-x_48 = lean_ctor_get(x_46, 3);
-lean_inc(x_48);
-if (lean_obj_tag(x_48) == 0)
-{
-uint8_t x_49; 
-x_49 = !lean_is_exclusive(x_46);
+uint32_t x_48; uint8_t x_49; 
+x_48 = lean_unbox_uint32(x_43);
+x_49 = x_48 < x_2;
 if (x_49 == 0)
 {
-lean_object* x_50; lean_object* x_51; uint8_t x_52; uint8_t x_53; 
-x_50 = lean_ctor_get(x_46, 3);
-lean_dec(x_50);
-x_51 = lean_ctor_get(x_46, 0);
-lean_dec(x_51);
-x_52 = 0;
-lean_ctor_set(x_46, 0, x_48);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_52);
-x_53 = 1;
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_53);
+uint8_t x_50; lean_object* x_51; 
+lean_dec(x_44);
+lean_dec(x_43);
+x_50 = 1;
+x_51 = lean_box_uint32(x_2);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_51);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_50);
 return x_1;
 }
 else
 {
-lean_object* x_54; lean_object* x_55; uint8_t x_56; lean_object* x_57; uint8_t x_58; 
-x_54 = lean_ctor_get(x_46, 1);
-x_55 = lean_ctor_get(x_46, 2);
-lean_inc(x_55);
-lean_inc(x_54);
-lean_dec(x_46);
-x_56 = 0;
-x_57 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_57, 0, x_48);
-lean_ctor_set(x_57, 1, x_54);
-lean_ctor_set(x_57, 2, x_55);
-lean_ctor_set(x_57, 3, x_48);
-lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_56);
-x_58 = 1;
-lean_ctor_set(x_1, 3, x_57);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_58);
+uint8_t x_52; 
+x_52 = l_Std_RBNode_isRed___rarg(x_45);
+if (x_52 == 0)
+{
+lean_object* x_53; uint8_t x_54; 
+x_53 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_45, x_2, x_3);
+x_54 = 1;
+lean_ctor_set(x_1, 3, x_53);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_54);
+return x_1;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; 
+x_55 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_45, x_2, x_3);
+x_56 = lean_ctor_get(x_55, 0);
+lean_inc(x_56);
+if (lean_obj_tag(x_56) == 0)
+{
+lean_object* x_57; 
+x_57 = lean_ctor_get(x_55, 3);
+lean_inc(x_57);
+if (lean_obj_tag(x_57) == 0)
+{
+uint8_t x_58; 
+x_58 = !lean_is_exclusive(x_55);
+if (x_58 == 0)
+{
+lean_object* x_59; lean_object* x_60; uint8_t x_61; uint8_t x_62; 
+x_59 = lean_ctor_get(x_55, 3);
+lean_dec(x_59);
+x_60 = lean_ctor_get(x_55, 0);
+lean_dec(x_60);
+x_61 = 0;
+lean_ctor_set(x_55, 0, x_57);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_61);
+x_62 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_62);
+return x_1;
+}
+else
+{
+lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; uint8_t x_67; 
+x_63 = lean_ctor_get(x_55, 1);
+x_64 = lean_ctor_get(x_55, 2);
+lean_inc(x_64);
+lean_inc(x_63);
+lean_dec(x_55);
+x_65 = 0;
+x_66 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_66, 0, x_57);
+lean_ctor_set(x_66, 1, x_63);
+lean_ctor_set(x_66, 2, x_64);
+lean_ctor_set(x_66, 3, x_57);
+lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
+x_67 = 1;
+lean_ctor_set(x_1, 3, x_66);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_67);
 return x_1;
 }
 }
 else
 {
-uint8_t x_59; 
-x_59 = lean_ctor_get_uint8(x_48, sizeof(void*)*4);
-if (x_59 == 0)
+uint8_t x_68; 
+x_68 = lean_ctor_get_uint8(x_57, sizeof(void*)*4);
+if (x_68 == 0)
 {
-uint8_t x_60; 
-x_60 = !lean_is_exclusive(x_46);
-if (x_60 == 0)
+uint8_t x_69; 
+x_69 = !lean_is_exclusive(x_55);
+if (x_69 == 0)
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; 
-x_61 = lean_ctor_get(x_46, 1);
-x_62 = lean_ctor_get(x_46, 2);
-x_63 = lean_ctor_get(x_46, 3);
-lean_dec(x_63);
-x_64 = lean_ctor_get(x_46, 0);
-lean_dec(x_64);
-x_65 = !lean_is_exclusive(x_48);
-if (x_65 == 0)
+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_55, 1);
+x_71 = lean_ctor_get(x_55, 2);
+x_72 = lean_ctor_get(x_55, 3);
+lean_dec(x_72);
+x_73 = lean_ctor_get(x_55, 0);
+lean_dec(x_73);
+x_74 = !lean_is_exclusive(x_57);
+if (x_74 == 0)
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; 
-x_66 = lean_ctor_get(x_48, 0);
-x_67 = lean_ctor_get(x_48, 1);
-x_68 = lean_ctor_get(x_48, 2);
-x_69 = lean_ctor_get(x_48, 3);
-x_70 = 1;
-lean_ctor_set(x_48, 3, x_47);
-lean_ctor_set(x_48, 2, x_37);
-lean_ctor_set(x_48, 1, x_36);
-lean_ctor_set(x_48, 0, x_35);
-lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_70);
-lean_ctor_set(x_46, 3, x_69);
-lean_ctor_set(x_46, 2, x_68);
-lean_ctor_set(x_46, 1, x_67);
-lean_ctor_set(x_46, 0, x_66);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_70);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_48);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; uint8_t x_80; 
+x_75 = lean_ctor_get(x_57, 0);
+x_76 = lean_ctor_get(x_57, 1);
+x_77 = lean_ctor_get(x_57, 2);
+x_78 = lean_ctor_get(x_57, 3);
+x_79 = 1;
+lean_ctor_set(x_57, 3, x_56);
+lean_ctor_set(x_57, 2, x_44);
+lean_ctor_set(x_57, 1, x_43);
+lean_ctor_set(x_57, 0, x_42);
+lean_ctor_set_uint8(x_57, sizeof(void*)*4, x_79);
+lean_ctor_set(x_55, 3, x_78);
+lean_ctor_set(x_55, 2, x_77);
+lean_ctor_set(x_55, 1, x_76);
+lean_ctor_set(x_55, 0, x_75);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_79);
+x_80 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_57);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_80);
 return x_1;
 }
 else
 {
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; 
-x_71 = lean_ctor_get(x_48, 0);
-x_72 = lean_ctor_get(x_48, 1);
-x_73 = lean_ctor_get(x_48, 2);
-x_74 = lean_ctor_get(x_48, 3);
-lean_inc(x_74);
-lean_inc(x_73);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_dec(x_48);
-x_75 = 1;
-x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_35);
-lean_ctor_set(x_76, 1, x_36);
-lean_ctor_set(x_76, 2, x_37);
-lean_ctor_set(x_76, 3, x_47);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
-lean_ctor_set(x_46, 3, x_74);
-lean_ctor_set(x_46, 2, x_73);
-lean_ctor_set(x_46, 1, x_72);
-lean_ctor_set(x_46, 0, x_71);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_75);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_62);
-lean_ctor_set(x_1, 1, x_61);
-lean_ctor_set(x_1, 0, x_76);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-}
-else
-{
-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; uint8_t x_84; lean_object* x_85; lean_object* x_86; 
-x_77 = lean_ctor_get(x_46, 1);
-x_78 = lean_ctor_get(x_46, 2);
-lean_inc(x_78);
-lean_inc(x_77);
-lean_dec(x_46);
-x_79 = lean_ctor_get(x_48, 0);
-lean_inc(x_79);
-x_80 = lean_ctor_get(x_48, 1);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_48, 2);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_48, 3);
+lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; lean_object* x_86; uint8_t x_87; 
+x_81 = lean_ctor_get(x_57, 0);
+x_82 = lean_ctor_get(x_57, 1);
+x_83 = lean_ctor_get(x_57, 2);
+x_84 = lean_ctor_get(x_57, 3);
+lean_inc(x_84);
+lean_inc(x_83);
 lean_inc(x_82);
-if (lean_is_exclusive(x_48)) {
- lean_ctor_release(x_48, 0);
- lean_ctor_release(x_48, 1);
- lean_ctor_release(x_48, 2);
- lean_ctor_release(x_48, 3);
- x_83 = x_48;
-} else {
- lean_dec_ref(x_48);
- x_83 = lean_box(0);
-}
-x_84 = 1;
-if (lean_is_scalar(x_83)) {
- x_85 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_85 = x_83;
-}
-lean_ctor_set(x_85, 0, x_35);
-lean_ctor_set(x_85, 1, x_36);
-lean_ctor_set(x_85, 2, x_37);
-lean_ctor_set(x_85, 3, x_47);
-lean_ctor_set_uint8(x_85, sizeof(void*)*4, x_84);
+lean_inc(x_81);
+lean_dec(x_57);
+x_85 = 1;
 x_86 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_86, 0, x_79);
-lean_ctor_set(x_86, 1, x_80);
-lean_ctor_set(x_86, 2, x_81);
-lean_ctor_set(x_86, 3, x_82);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_84);
-lean_ctor_set(x_1, 3, x_86);
-lean_ctor_set(x_1, 2, x_78);
-lean_ctor_set(x_1, 1, x_77);
-lean_ctor_set(x_1, 0, x_85);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+lean_ctor_set(x_86, 0, x_42);
+lean_ctor_set(x_86, 1, x_43);
+lean_ctor_set(x_86, 2, x_44);
+lean_ctor_set(x_86, 3, x_56);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+lean_ctor_set(x_55, 3, x_84);
+lean_ctor_set(x_55, 2, x_83);
+lean_ctor_set(x_55, 1, x_82);
+lean_ctor_set(x_55, 0, x_81);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_85);
+x_87 = 0;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_71);
+lean_ctor_set(x_1, 1, x_70);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_87);
 return x_1;
 }
 }
 else
 {
-uint8_t x_87; 
-x_87 = !lean_is_exclusive(x_46);
-if (x_87 == 0)
-{
-lean_object* x_88; lean_object* x_89; uint8_t x_90; 
-x_88 = lean_ctor_get(x_46, 3);
-lean_dec(x_88);
-x_89 = lean_ctor_get(x_46, 0);
-lean_dec(x_89);
-x_90 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_90);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
-return x_1;
-}
-else
-{
-lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; 
-x_91 = lean_ctor_get(x_46, 1);
-x_92 = lean_ctor_get(x_46, 2);
-lean_inc(x_92);
+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; uint8_t x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; 
+x_88 = lean_ctor_get(x_55, 1);
+x_89 = lean_ctor_get(x_55, 2);
+lean_inc(x_89);
+lean_inc(x_88);
+lean_dec(x_55);
+x_90 = lean_ctor_get(x_57, 0);
+lean_inc(x_90);
+x_91 = lean_ctor_get(x_57, 1);
 lean_inc(x_91);
-lean_dec(x_46);
-x_93 = 0;
-x_94 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_94, 0, x_47);
-lean_ctor_set(x_94, 1, x_91);
-lean_ctor_set(x_94, 2, x_92);
-lean_ctor_set(x_94, 3, x_48);
-lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_94);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_59);
+x_92 = lean_ctor_get(x_57, 2);
+lean_inc(x_92);
+x_93 = lean_ctor_get(x_57, 3);
+lean_inc(x_93);
+if (lean_is_exclusive(x_57)) {
+ lean_ctor_release(x_57, 0);
+ lean_ctor_release(x_57, 1);
+ lean_ctor_release(x_57, 2);
+ lean_ctor_release(x_57, 3);
+ x_94 = x_57;
+} else {
+ lean_dec_ref(x_57);
+ x_94 = lean_box(0);
+}
+x_95 = 1;
+if (lean_is_scalar(x_94)) {
+ x_96 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_96 = x_94;
+}
+lean_ctor_set(x_96, 0, x_42);
+lean_ctor_set(x_96, 1, x_43);
+lean_ctor_set(x_96, 2, x_44);
+lean_ctor_set(x_96, 3, x_56);
+lean_ctor_set_uint8(x_96, sizeof(void*)*4, x_95);
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_90);
+lean_ctor_set(x_97, 1, x_91);
+lean_ctor_set(x_97, 2, x_92);
+lean_ctor_set(x_97, 3, x_93);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_95);
+x_98 = 0;
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set(x_1, 2, x_89);
+lean_ctor_set(x_1, 1, x_88);
+lean_ctor_set(x_1, 0, x_96);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_95; 
-x_95 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
-if (x_95 == 0)
+uint8_t x_99; 
+x_99 = !lean_is_exclusive(x_55);
+if (x_99 == 0)
 {
-uint8_t x_96; 
-x_96 = !lean_is_exclusive(x_46);
-if (x_96 == 0)
-{
-lean_object* x_97; uint8_t x_98; 
-x_97 = lean_ctor_get(x_46, 0);
-lean_dec(x_97);
-x_98 = !lean_is_exclusive(x_47);
-if (x_98 == 0)
-{
-lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; uint8_t x_103; 
-x_99 = lean_ctor_get(x_47, 0);
-x_100 = lean_ctor_get(x_47, 1);
-x_101 = lean_ctor_get(x_47, 2);
-x_102 = lean_ctor_get(x_47, 3);
+lean_object* x_100; lean_object* x_101; uint8_t x_102; uint8_t x_103; 
+x_100 = lean_ctor_get(x_55, 3);
+lean_dec(x_100);
+x_101 = lean_ctor_get(x_55, 0);
+lean_dec(x_101);
+x_102 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_102);
 x_103 = 1;
-lean_ctor_set(x_47, 3, x_99);
-lean_ctor_set(x_47, 2, x_37);
-lean_ctor_set(x_47, 1, x_36);
-lean_ctor_set(x_47, 0, x_35);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_103);
-lean_ctor_set(x_46, 0, x_102);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_103);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_101);
-lean_ctor_set(x_1, 1, x_100);
-lean_ctor_set(x_1, 0, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_103);
 return x_1;
 }
 else
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; 
-x_104 = lean_ctor_get(x_47, 0);
-x_105 = lean_ctor_get(x_47, 1);
-x_106 = lean_ctor_get(x_47, 2);
-x_107 = lean_ctor_get(x_47, 3);
-lean_inc(x_107);
-lean_inc(x_106);
+lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; uint8_t x_108; 
+x_104 = lean_ctor_get(x_55, 1);
+x_105 = lean_ctor_get(x_55, 2);
 lean_inc(x_105);
 lean_inc(x_104);
-lean_dec(x_47);
+lean_dec(x_55);
+x_106 = 0;
+x_107 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_107, 0, x_56);
+lean_ctor_set(x_107, 1, x_104);
+lean_ctor_set(x_107, 2, x_105);
+lean_ctor_set(x_107, 3, x_57);
+lean_ctor_set_uint8(x_107, sizeof(void*)*4, x_106);
 x_108 = 1;
-x_109 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_109, 0, x_35);
-lean_ctor_set(x_109, 1, x_36);
-lean_ctor_set(x_109, 2, x_37);
-lean_ctor_set(x_109, 3, x_104);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-lean_ctor_set(x_46, 0, x_107);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set(x_1, 2, x_106);
-lean_ctor_set(x_1, 1, x_105);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_107);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; lean_object* x_120; 
-x_110 = lean_ctor_get(x_46, 1);
-x_111 = lean_ctor_get(x_46, 2);
-x_112 = lean_ctor_get(x_46, 3);
-lean_inc(x_112);
-lean_inc(x_111);
-lean_inc(x_110);
-lean_dec(x_46);
-x_113 = lean_ctor_get(x_47, 0);
-lean_inc(x_113);
-x_114 = lean_ctor_get(x_47, 1);
-lean_inc(x_114);
-x_115 = lean_ctor_get(x_47, 2);
-lean_inc(x_115);
-x_116 = lean_ctor_get(x_47, 3);
-lean_inc(x_116);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_117 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_117 = lean_box(0);
-}
-x_118 = 1;
-if (lean_is_scalar(x_117)) {
- x_119 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_119 = x_117;
-}
-lean_ctor_set(x_119, 0, x_35);
-lean_ctor_set(x_119, 1, x_36);
-lean_ctor_set(x_119, 2, x_37);
-lean_ctor_set(x_119, 3, x_113);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-x_120 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_120, 0, x_116);
-lean_ctor_set(x_120, 1, x_110);
-lean_ctor_set(x_120, 2, x_111);
-lean_ctor_set(x_120, 3, x_112);
-lean_ctor_set_uint8(x_120, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_120);
+uint8_t x_109; 
+x_109 = lean_ctor_get_uint8(x_56, sizeof(void*)*4);
+if (x_109 == 0)
+{
+uint8_t x_110; 
+x_110 = !lean_is_exclusive(x_55);
+if (x_110 == 0)
+{
+lean_object* x_111; uint8_t x_112; 
+x_111 = lean_ctor_get(x_55, 0);
+lean_dec(x_111);
+x_112 = !lean_is_exclusive(x_56);
+if (x_112 == 0)
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint8_t x_117; uint8_t x_118; 
+x_113 = lean_ctor_get(x_56, 0);
+x_114 = lean_ctor_get(x_56, 1);
+x_115 = lean_ctor_get(x_56, 2);
+x_116 = lean_ctor_get(x_56, 3);
+x_117 = 1;
+lean_ctor_set(x_56, 3, x_113);
+lean_ctor_set(x_56, 2, x_44);
+lean_ctor_set(x_56, 1, x_43);
+lean_ctor_set(x_56, 0, x_42);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_117);
+lean_ctor_set(x_55, 0, x_116);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_117);
+x_118 = 0;
+lean_ctor_set(x_1, 3, x_55);
 lean_ctor_set(x_1, 2, x_115);
 lean_ctor_set(x_1, 1, x_114);
-lean_ctor_set(x_1, 0, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 0, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_118);
 return x_1;
 }
-}
 else
 {
-lean_object* x_121; 
-x_121 = lean_ctor_get(x_46, 3);
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; lean_object* x_124; uint8_t x_125; 
+x_119 = lean_ctor_get(x_56, 0);
+x_120 = lean_ctor_get(x_56, 1);
+x_121 = lean_ctor_get(x_56, 2);
+x_122 = lean_ctor_get(x_56, 3);
+lean_inc(x_122);
 lean_inc(x_121);
-if (lean_obj_tag(x_121) == 0)
-{
-uint8_t x_122; 
-x_122 = !lean_is_exclusive(x_46);
-if (x_122 == 0)
-{
-lean_object* x_123; lean_object* x_124; uint8_t x_125; 
-x_123 = lean_ctor_get(x_46, 3);
-lean_dec(x_123);
-x_124 = lean_ctor_get(x_46, 0);
-lean_dec(x_124);
+lean_inc(x_120);
+lean_inc(x_119);
+lean_dec(x_56);
+x_123 = 1;
+x_124 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_124, 0, x_42);
+lean_ctor_set(x_124, 1, x_43);
+lean_ctor_set(x_124, 2, x_44);
+lean_ctor_set(x_124, 3, x_119);
+lean_ctor_set_uint8(x_124, sizeof(void*)*4, x_123);
+lean_ctor_set(x_55, 0, x_122);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_123);
 x_125 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_125);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_124);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_125);
 return x_1;
 }
+}
 else
 {
-lean_object* x_126; lean_object* x_127; uint8_t x_128; lean_object* x_129; 
-x_126 = lean_ctor_get(x_46, 1);
-x_127 = lean_ctor_get(x_46, 2);
+lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; uint8_t x_137; 
+x_126 = lean_ctor_get(x_55, 1);
+x_127 = lean_ctor_get(x_55, 2);
+x_128 = lean_ctor_get(x_55, 3);
+lean_inc(x_128);
 lean_inc(x_127);
 lean_inc(x_126);
-lean_dec(x_46);
-x_128 = 0;
-x_129 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_129, 0, x_47);
-lean_ctor_set(x_129, 1, x_126);
-lean_ctor_set(x_129, 2, x_127);
-lean_ctor_set(x_129, 3, x_121);
-lean_ctor_set_uint8(x_129, sizeof(void*)*4, x_128);
-lean_ctor_set(x_1, 3, x_129);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_95);
+lean_dec(x_55);
+x_129 = lean_ctor_get(x_56, 0);
+lean_inc(x_129);
+x_130 = lean_ctor_get(x_56, 1);
+lean_inc(x_130);
+x_131 = lean_ctor_get(x_56, 2);
+lean_inc(x_131);
+x_132 = lean_ctor_get(x_56, 3);
+lean_inc(x_132);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_133 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_133 = lean_box(0);
+}
+x_134 = 1;
+if (lean_is_scalar(x_133)) {
+ x_135 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_135 = x_133;
+}
+lean_ctor_set(x_135, 0, x_42);
+lean_ctor_set(x_135, 1, x_43);
+lean_ctor_set(x_135, 2, x_44);
+lean_ctor_set(x_135, 3, x_129);
+lean_ctor_set_uint8(x_135, sizeof(void*)*4, x_134);
+x_136 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_136, 0, x_132);
+lean_ctor_set(x_136, 1, x_126);
+lean_ctor_set(x_136, 2, x_127);
+lean_ctor_set(x_136, 3, x_128);
+lean_ctor_set_uint8(x_136, sizeof(void*)*4, x_134);
+x_137 = 0;
+lean_ctor_set(x_1, 3, x_136);
+lean_ctor_set(x_1, 2, x_131);
+lean_ctor_set(x_1, 1, x_130);
+lean_ctor_set(x_1, 0, x_135);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_137);
 return x_1;
 }
 }
 else
 {
-uint8_t x_130; 
-x_130 = lean_ctor_get_uint8(x_121, sizeof(void*)*4);
-if (x_130 == 0)
+lean_object* x_138; 
+x_138 = lean_ctor_get(x_55, 3);
+lean_inc(x_138);
+if (lean_obj_tag(x_138) == 0)
 {
-uint8_t x_131; 
-lean_free_object(x_1);
-x_131 = !lean_is_exclusive(x_46);
-if (x_131 == 0)
-{
-lean_object* x_132; lean_object* x_133; uint8_t x_134; 
-x_132 = lean_ctor_get(x_46, 3);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_46, 0);
-lean_dec(x_133);
-x_134 = !lean_is_exclusive(x_121);
-if (x_134 == 0)
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; 
-x_135 = lean_ctor_get(x_121, 0);
-x_136 = lean_ctor_get(x_121, 1);
-x_137 = lean_ctor_get(x_121, 2);
-x_138 = lean_ctor_get(x_121, 3);
-lean_inc(x_47);
-lean_ctor_set(x_121, 3, x_47);
-lean_ctor_set(x_121, 2, x_37);
-lean_ctor_set(x_121, 1, x_36);
-lean_ctor_set(x_121, 0, x_35);
-x_139 = !lean_is_exclusive(x_47);
+uint8_t x_139; 
+x_139 = !lean_is_exclusive(x_55);
 if (x_139 == 0)
 {
-lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; 
-x_140 = lean_ctor_get(x_47, 3);
+lean_object* x_140; lean_object* x_141; uint8_t x_142; uint8_t x_143; 
+x_140 = lean_ctor_get(x_55, 3);
 lean_dec(x_140);
-x_141 = lean_ctor_get(x_47, 2);
+x_141 = lean_ctor_get(x_55, 0);
 lean_dec(x_141);
-x_142 = lean_ctor_get(x_47, 1);
-lean_dec(x_142);
-x_143 = lean_ctor_get(x_47, 0);
-lean_dec(x_143);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-lean_ctor_set(x_47, 3, x_138);
-lean_ctor_set(x_47, 2, x_137);
-lean_ctor_set(x_47, 1, x_136);
-lean_ctor_set(x_47, 0, x_135);
-lean_ctor_set(x_46, 3, x_47);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-else
-{
-lean_object* x_144; 
-lean_dec(x_47);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_95);
-x_144 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_144, 0, x_135);
-lean_ctor_set(x_144, 1, x_136);
-lean_ctor_set(x_144, 2, x_137);
-lean_ctor_set(x_144, 3, x_138);
-lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_144);
-lean_ctor_set(x_46, 0, x_121);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
-x_145 = lean_ctor_get(x_121, 0);
-x_146 = lean_ctor_get(x_121, 1);
-x_147 = lean_ctor_get(x_121, 2);
-x_148 = lean_ctor_get(x_121, 3);
-lean_inc(x_148);
-lean_inc(x_147);
-lean_inc(x_146);
-lean_inc(x_145);
-lean_dec(x_121);
-lean_inc(x_47);
-x_149 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_149, 0, x_35);
-lean_ctor_set(x_149, 1, x_36);
-lean_ctor_set(x_149, 2, x_37);
-lean_ctor_set(x_149, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_150 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_145);
-lean_ctor_set(x_151, 1, x_146);
-lean_ctor_set(x_151, 2, x_147);
-lean_ctor_set(x_151, 3, x_148);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_95);
-lean_ctor_set(x_46, 3, x_151);
-lean_ctor_set(x_46, 0, x_149);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_130);
-return x_46;
-}
-}
-else
-{
-lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
-x_152 = lean_ctor_get(x_46, 1);
-x_153 = lean_ctor_get(x_46, 2);
-lean_inc(x_153);
-lean_inc(x_152);
-lean_dec(x_46);
-x_154 = lean_ctor_get(x_121, 0);
-lean_inc(x_154);
-x_155 = lean_ctor_get(x_121, 1);
-lean_inc(x_155);
-x_156 = lean_ctor_get(x_121, 2);
-lean_inc(x_156);
-x_157 = lean_ctor_get(x_121, 3);
-lean_inc(x_157);
-if (lean_is_exclusive(x_121)) {
- lean_ctor_release(x_121, 0);
- lean_ctor_release(x_121, 1);
- lean_ctor_release(x_121, 2);
- lean_ctor_release(x_121, 3);
- x_158 = x_121;
-} else {
- lean_dec_ref(x_121);
- x_158 = lean_box(0);
-}
-lean_inc(x_47);
-if (lean_is_scalar(x_158)) {
- x_159 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_159 = x_158;
-}
-lean_ctor_set(x_159, 0, x_35);
-lean_ctor_set(x_159, 1, x_36);
-lean_ctor_set(x_159, 2, x_37);
-lean_ctor_set(x_159, 3, x_47);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_160 = x_47;
-} else {
- lean_dec_ref(x_47);
- x_160 = lean_box(0);
-}
-lean_ctor_set_uint8(x_159, sizeof(void*)*4, x_95);
-if (lean_is_scalar(x_160)) {
- x_161 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_161 = x_160;
-}
-lean_ctor_set(x_161, 0, x_154);
-lean_ctor_set(x_161, 1, x_155);
-lean_ctor_set(x_161, 2, x_156);
-lean_ctor_set(x_161, 3, x_157);
-lean_ctor_set_uint8(x_161, sizeof(void*)*4, x_95);
-x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_159);
-lean_ctor_set(x_162, 1, x_152);
-lean_ctor_set(x_162, 2, x_153);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_130);
-return x_162;
-}
-}
-else
-{
-uint8_t x_163; 
-x_163 = !lean_is_exclusive(x_46);
-if (x_163 == 0)
-{
-lean_object* x_164; lean_object* x_165; uint8_t x_166; 
-x_164 = lean_ctor_get(x_46, 3);
-lean_dec(x_164);
-x_165 = lean_ctor_get(x_46, 0);
-lean_dec(x_165);
-x_166 = !lean_is_exclusive(x_47);
-if (x_166 == 0)
-{
-uint8_t x_167; 
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_130);
-x_167 = 0;
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_167);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
+x_142 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_142);
+x_143 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_143);
 return x_1;
 }
 else
 {
-lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; 
-x_168 = lean_ctor_get(x_47, 0);
-x_169 = lean_ctor_get(x_47, 1);
-x_170 = lean_ctor_get(x_47, 2);
-x_171 = lean_ctor_get(x_47, 3);
-lean_inc(x_171);
+lean_object* x_144; lean_object* x_145; uint8_t x_146; lean_object* x_147; uint8_t x_148; 
+x_144 = lean_ctor_get(x_55, 1);
+x_145 = lean_ctor_get(x_55, 2);
+lean_inc(x_145);
+lean_inc(x_144);
+lean_dec(x_55);
+x_146 = 0;
+x_147 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_147, 0, x_56);
+lean_ctor_set(x_147, 1, x_144);
+lean_ctor_set(x_147, 2, x_145);
+lean_ctor_set(x_147, 3, x_138);
+lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_146);
+x_148 = 1;
+lean_ctor_set(x_1, 3, x_147);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_148);
+return x_1;
+}
+}
+else
+{
+uint8_t x_149; 
+x_149 = lean_ctor_get_uint8(x_138, sizeof(void*)*4);
+if (x_149 == 0)
+{
+uint8_t x_150; 
+lean_free_object(x_1);
+x_150 = !lean_is_exclusive(x_55);
+if (x_150 == 0)
+{
+lean_object* x_151; lean_object* x_152; uint8_t x_153; 
+x_151 = lean_ctor_get(x_55, 3);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_55, 0);
+lean_dec(x_152);
+x_153 = !lean_is_exclusive(x_138);
+if (x_153 == 0)
+{
+lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; uint8_t x_158; uint8_t x_159; 
+x_154 = lean_ctor_get(x_138, 0);
+x_155 = lean_ctor_get(x_138, 1);
+x_156 = lean_ctor_get(x_138, 2);
+x_157 = lean_ctor_get(x_138, 3);
+x_158 = 1;
+lean_inc(x_56);
+lean_ctor_set(x_138, 3, x_56);
+lean_ctor_set(x_138, 2, x_44);
+lean_ctor_set(x_138, 1, x_43);
+lean_ctor_set(x_138, 0, x_42);
+x_159 = !lean_is_exclusive(x_56);
+if (x_159 == 0)
+{
+lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; uint8_t x_164; 
+x_160 = lean_ctor_get(x_56, 3);
+lean_dec(x_160);
+x_161 = lean_ctor_get(x_56, 2);
+lean_dec(x_161);
+x_162 = lean_ctor_get(x_56, 1);
+lean_dec(x_162);
+x_163 = lean_ctor_get(x_56, 0);
+lean_dec(x_163);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+lean_ctor_set(x_56, 3, x_157);
+lean_ctor_set(x_56, 2, x_156);
+lean_ctor_set(x_56, 1, x_155);
+lean_ctor_set(x_56, 0, x_154);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_158);
+x_164 = 0;
+lean_ctor_set(x_55, 3, x_56);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_164);
+return x_55;
+}
+else
+{
+lean_object* x_165; uint8_t x_166; 
+lean_dec(x_56);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_158);
+x_165 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_165, 0, x_154);
+lean_ctor_set(x_165, 1, x_155);
+lean_ctor_set(x_165, 2, x_156);
+lean_ctor_set(x_165, 3, x_157);
+lean_ctor_set_uint8(x_165, sizeof(void*)*4, x_158);
+x_166 = 0;
+lean_ctor_set(x_55, 3, x_165);
+lean_ctor_set(x_55, 0, x_138);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_166);
+return x_55;
+}
+}
+else
+{
+lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; 
+x_167 = lean_ctor_get(x_138, 0);
+x_168 = lean_ctor_get(x_138, 1);
+x_169 = lean_ctor_get(x_138, 2);
+x_170 = lean_ctor_get(x_138, 3);
 lean_inc(x_170);
 lean_inc(x_169);
 lean_inc(x_168);
-lean_dec(x_47);
+lean_inc(x_167);
+lean_dec(x_138);
+x_171 = 1;
+lean_inc(x_56);
 x_172 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_172, 0, x_168);
-lean_ctor_set(x_172, 1, x_169);
-lean_ctor_set(x_172, 2, x_170);
-lean_ctor_set(x_172, 3, x_171);
-lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_130);
-x_173 = 0;
-lean_ctor_set(x_46, 0, x_172);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_173);
-lean_ctor_set(x_1, 3, x_46);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
+lean_ctor_set(x_172, 0, x_42);
+lean_ctor_set(x_172, 1, x_43);
+lean_ctor_set(x_172, 2, x_44);
+lean_ctor_set(x_172, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_173 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_173 = lean_box(0);
+}
+lean_ctor_set_uint8(x_172, sizeof(void*)*4, x_171);
+if (lean_is_scalar(x_173)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_174 = x_173;
+}
+lean_ctor_set(x_174, 0, x_167);
+lean_ctor_set(x_174, 1, x_168);
+lean_ctor_set(x_174, 2, x_169);
+lean_ctor_set(x_174, 3, x_170);
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_171);
+x_175 = 0;
+lean_ctor_set(x_55, 3, x_174);
+lean_ctor_set(x_55, 0, x_172);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_175);
+return x_55;
 }
 }
 else
 {
-lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; uint8_t x_182; lean_object* x_183; 
-x_174 = lean_ctor_get(x_46, 1);
-x_175 = lean_ctor_get(x_46, 2);
-lean_inc(x_175);
-lean_inc(x_174);
-lean_dec(x_46);
-x_176 = lean_ctor_get(x_47, 0);
-lean_inc(x_176);
-x_177 = lean_ctor_get(x_47, 1);
+lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; uint8_t x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; uint8_t x_187; lean_object* x_188; 
+x_176 = lean_ctor_get(x_55, 1);
+x_177 = lean_ctor_get(x_55, 2);
 lean_inc(x_177);
-x_178 = lean_ctor_get(x_47, 2);
+lean_inc(x_176);
+lean_dec(x_55);
+x_178 = lean_ctor_get(x_138, 0);
 lean_inc(x_178);
-x_179 = lean_ctor_get(x_47, 3);
+x_179 = lean_ctor_get(x_138, 1);
 lean_inc(x_179);
-if (lean_is_exclusive(x_47)) {
- lean_ctor_release(x_47, 0);
- lean_ctor_release(x_47, 1);
- lean_ctor_release(x_47, 2);
- lean_ctor_release(x_47, 3);
- x_180 = x_47;
+x_180 = lean_ctor_get(x_138, 2);
+lean_inc(x_180);
+x_181 = lean_ctor_get(x_138, 3);
+lean_inc(x_181);
+if (lean_is_exclusive(x_138)) {
+ lean_ctor_release(x_138, 0);
+ lean_ctor_release(x_138, 1);
+ lean_ctor_release(x_138, 2);
+ lean_ctor_release(x_138, 3);
+ x_182 = x_138;
 } else {
- lean_dec_ref(x_47);
- x_180 = lean_box(0);
+ lean_dec_ref(x_138);
+ x_182 = lean_box(0);
 }
-if (lean_is_scalar(x_180)) {
- x_181 = lean_alloc_ctor(1, 4, 1);
+x_183 = 1;
+lean_inc(x_56);
+if (lean_is_scalar(x_182)) {
+ x_184 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_181 = x_180;
-}
-lean_ctor_set(x_181, 0, x_176);
-lean_ctor_set(x_181, 1, x_177);
-lean_ctor_set(x_181, 2, x_178);
-lean_ctor_set(x_181, 3, x_179);
-lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_130);
-x_182 = 0;
-x_183 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_183, 0, x_181);
-lean_ctor_set(x_183, 1, x_174);
-lean_ctor_set(x_183, 2, x_175);
-lean_ctor_set(x_183, 3, x_121);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_182);
-lean_ctor_set(x_1, 3, x_183);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_130);
-return x_1;
-}
-}
-}
+ x_184 = x_182;
 }
+lean_ctor_set(x_184, 0, x_42);
+lean_ctor_set(x_184, 1, x_43);
+lean_ctor_set(x_184, 2, x_44);
+lean_ctor_set(x_184, 3, x_56);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_185 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_185 = lean_box(0);
 }
+lean_ctor_set_uint8(x_184, sizeof(void*)*4, x_183);
+if (lean_is_scalar(x_185)) {
+ x_186 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_186 = x_185;
 }
+lean_ctor_set(x_186, 0, x_178);
+lean_ctor_set(x_186, 1, x_179);
+lean_ctor_set(x_186, 2, x_180);
+lean_ctor_set(x_186, 3, x_181);
+lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_183);
+x_187 = 0;
+x_188 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_188, 0, x_184);
+lean_ctor_set(x_188, 1, x_176);
+lean_ctor_set(x_188, 2, x_177);
+lean_ctor_set(x_188, 3, x_186);
+lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_187);
+return x_188;
 }
 }
 else
 {
-uint8_t x_184; 
-x_184 = l_Std_RBNode_isRed___rarg(x_35);
-if (x_184 == 0)
-{
-lean_object* x_185; 
-x_185 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_35, x_2, x_3);
-lean_ctor_set(x_1, 0, x_185);
-return x_1;
-}
-else
-{
-lean_object* x_186; lean_object* x_187; 
-x_186 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_35, x_2, x_3);
-x_187 = lean_ctor_get(x_186, 0);
-lean_inc(x_187);
-if (lean_obj_tag(x_187) == 0)
-{
-lean_object* x_188; 
-x_188 = lean_ctor_get(x_186, 3);
-lean_inc(x_188);
-if (lean_obj_tag(x_188) == 0)
-{
 uint8_t x_189; 
-x_189 = !lean_is_exclusive(x_186);
+x_189 = !lean_is_exclusive(x_55);
 if (x_189 == 0)
 {
-lean_object* x_190; lean_object* x_191; uint8_t x_192; uint8_t x_193; 
-x_190 = lean_ctor_get(x_186, 3);
+lean_object* x_190; lean_object* x_191; uint8_t x_192; 
+x_190 = lean_ctor_get(x_55, 3);
 lean_dec(x_190);
-x_191 = lean_ctor_get(x_186, 0);
+x_191 = lean_ctor_get(x_55, 0);
 lean_dec(x_191);
-x_192 = 0;
-lean_ctor_set(x_186, 0, x_188);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_192);
-x_193 = 1;
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_193);
+x_192 = !lean_is_exclusive(x_56);
+if (x_192 == 0)
+{
+uint8_t x_193; uint8_t x_194; 
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_149);
+x_193 = 0;
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_193);
+x_194 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_194);
 return x_1;
 }
 else
 {
-lean_object* x_194; lean_object* x_195; uint8_t x_196; lean_object* x_197; uint8_t x_198; 
-x_194 = lean_ctor_get(x_186, 1);
-x_195 = lean_ctor_get(x_186, 2);
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; uint8_t x_201; 
+x_195 = lean_ctor_get(x_56, 0);
+x_196 = lean_ctor_get(x_56, 1);
+x_197 = lean_ctor_get(x_56, 2);
+x_198 = lean_ctor_get(x_56, 3);
+lean_inc(x_198);
+lean_inc(x_197);
+lean_inc(x_196);
 lean_inc(x_195);
-lean_inc(x_194);
-lean_dec(x_186);
-x_196 = 0;
-x_197 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_197, 0, x_188);
-lean_ctor_set(x_197, 1, x_194);
-lean_ctor_set(x_197, 2, x_195);
-lean_ctor_set(x_197, 3, x_188);
-lean_ctor_set_uint8(x_197, sizeof(void*)*4, x_196);
-x_198 = 1;
-lean_ctor_set(x_1, 0, x_197);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_198);
+lean_dec(x_56);
+x_199 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_199, 0, x_195);
+lean_ctor_set(x_199, 1, x_196);
+lean_ctor_set(x_199, 2, x_197);
+lean_ctor_set(x_199, 3, x_198);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_149);
+x_200 = 0;
+lean_ctor_set(x_55, 0, x_199);
+lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_200);
+x_201 = 1;
+lean_ctor_set(x_1, 3, x_55);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_201);
 return x_1;
 }
 }
 else
 {
-uint8_t x_199; 
-x_199 = lean_ctor_get_uint8(x_188, sizeof(void*)*4);
-if (x_199 == 0)
-{
-uint8_t x_200; 
-x_200 = !lean_is_exclusive(x_186);
-if (x_200 == 0)
-{
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; 
-x_201 = lean_ctor_get(x_186, 1);
-x_202 = lean_ctor_get(x_186, 2);
-x_203 = lean_ctor_get(x_186, 3);
-lean_dec(x_203);
-x_204 = lean_ctor_get(x_186, 0);
-lean_dec(x_204);
-x_205 = !lean_is_exclusive(x_188);
-if (x_205 == 0)
-{
-lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; 
-x_206 = lean_ctor_get(x_188, 0);
-x_207 = lean_ctor_get(x_188, 1);
-x_208 = lean_ctor_get(x_188, 2);
-x_209 = lean_ctor_get(x_188, 3);
-x_210 = 1;
-lean_ctor_set(x_188, 3, x_206);
-lean_ctor_set(x_188, 2, x_202);
-lean_ctor_set(x_188, 1, x_201);
-lean_ctor_set(x_188, 0, x_187);
-lean_ctor_set_uint8(x_188, sizeof(void*)*4, x_210);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_209);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_210);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_208);
-lean_ctor_set(x_1, 1, x_207);
-lean_ctor_set(x_1, 0, x_188);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; uint8_t x_210; lean_object* x_211; uint8_t x_212; 
+x_202 = lean_ctor_get(x_55, 1);
+x_203 = lean_ctor_get(x_55, 2);
+lean_inc(x_203);
+lean_inc(x_202);
+lean_dec(x_55);
+x_204 = lean_ctor_get(x_56, 0);
+lean_inc(x_204);
+x_205 = lean_ctor_get(x_56, 1);
+lean_inc(x_205);
+x_206 = lean_ctor_get(x_56, 2);
+lean_inc(x_206);
+x_207 = lean_ctor_get(x_56, 3);
+lean_inc(x_207);
+if (lean_is_exclusive(x_56)) {
+ lean_ctor_release(x_56, 0);
+ lean_ctor_release(x_56, 1);
+ lean_ctor_release(x_56, 2);
+ lean_ctor_release(x_56, 3);
+ x_208 = x_56;
+} else {
+ lean_dec_ref(x_56);
+ x_208 = lean_box(0);
+}
+if (lean_is_scalar(x_208)) {
+ x_209 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_209 = x_208;
+}
+lean_ctor_set(x_209, 0, x_204);
+lean_ctor_set(x_209, 1, x_205);
+lean_ctor_set(x_209, 2, x_206);
+lean_ctor_set(x_209, 3, x_207);
+lean_ctor_set_uint8(x_209, sizeof(void*)*4, x_149);
+x_210 = 0;
+x_211 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_211, 0, x_209);
+lean_ctor_set(x_211, 1, x_202);
+lean_ctor_set(x_211, 2, x_203);
+lean_ctor_set(x_211, 3, x_138);
+lean_ctor_set_uint8(x_211, sizeof(void*)*4, x_210);
+x_212 = 1;
+lean_ctor_set(x_1, 3, x_211);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_212);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; uint8_t x_215; lean_object* x_216; 
-x_211 = lean_ctor_get(x_188, 0);
-x_212 = lean_ctor_get(x_188, 1);
-x_213 = lean_ctor_get(x_188, 2);
-x_214 = lean_ctor_get(x_188, 3);
-lean_inc(x_214);
-lean_inc(x_213);
-lean_inc(x_212);
-lean_inc(x_211);
-lean_dec(x_188);
+uint8_t x_213; 
+x_213 = l_Std_RBNode_isRed___rarg(x_42);
+if (x_213 == 0)
+{
+lean_object* x_214; uint8_t x_215; 
+x_214 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_42, x_2, x_3);
 x_215 = 1;
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_187);
-lean_ctor_set(x_216, 1, x_201);
-lean_ctor_set(x_216, 2, x_202);
-lean_ctor_set(x_216, 3, x_211);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_215);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_214);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_215);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_213);
-lean_ctor_set(x_1, 1, x_212);
-lean_ctor_set(x_1, 0, x_216);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+lean_ctor_set(x_1, 0, x_214);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_215);
 return x_1;
 }
-}
 else
 {
-lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; uint8_t x_224; lean_object* x_225; lean_object* x_226; 
-x_217 = lean_ctor_get(x_186, 1);
-x_218 = lean_ctor_get(x_186, 2);
-lean_inc(x_218);
+lean_object* x_216; lean_object* x_217; 
+x_216 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_42, x_2, x_3);
+x_217 = lean_ctor_get(x_216, 0);
 lean_inc(x_217);
-lean_dec(x_186);
-x_219 = lean_ctor_get(x_188, 0);
-lean_inc(x_219);
-x_220 = lean_ctor_get(x_188, 1);
-lean_inc(x_220);
-x_221 = lean_ctor_get(x_188, 2);
-lean_inc(x_221);
-x_222 = lean_ctor_get(x_188, 3);
-lean_inc(x_222);
-if (lean_is_exclusive(x_188)) {
- lean_ctor_release(x_188, 0);
- lean_ctor_release(x_188, 1);
- lean_ctor_release(x_188, 2);
- lean_ctor_release(x_188, 3);
- x_223 = x_188;
-} else {
- lean_dec_ref(x_188);
- x_223 = lean_box(0);
+if (lean_obj_tag(x_217) == 0)
+{
+lean_object* x_218; 
+x_218 = lean_ctor_get(x_216, 3);
+lean_inc(x_218);
+if (lean_obj_tag(x_218) == 0)
+{
+uint8_t x_219; 
+x_219 = !lean_is_exclusive(x_216);
+if (x_219 == 0)
+{
+lean_object* x_220; lean_object* x_221; uint8_t x_222; uint8_t x_223; 
+x_220 = lean_ctor_get(x_216, 3);
+lean_dec(x_220);
+x_221 = lean_ctor_get(x_216, 0);
+lean_dec(x_221);
+x_222 = 0;
+lean_ctor_set(x_216, 0, x_218);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_222);
+x_223 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_223);
+return x_1;
 }
-x_224 = 1;
-if (lean_is_scalar(x_223)) {
- x_225 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_225 = x_223;
-}
-lean_ctor_set(x_225, 0, x_187);
-lean_ctor_set(x_225, 1, x_217);
-lean_ctor_set(x_225, 2, x_218);
-lean_ctor_set(x_225, 3, x_219);
-lean_ctor_set_uint8(x_225, sizeof(void*)*4, x_224);
-x_226 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_226, 0, x_222);
-lean_ctor_set(x_226, 1, x_36);
-lean_ctor_set(x_226, 2, x_37);
-lean_ctor_set(x_226, 3, x_38);
-lean_ctor_set_uint8(x_226, sizeof(void*)*4, x_224);
-lean_ctor_set(x_1, 3, x_226);
-lean_ctor_set(x_1, 2, x_221);
-lean_ctor_set(x_1, 1, x_220);
-lean_ctor_set(x_1, 0, x_225);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
+else
+{
+lean_object* x_224; lean_object* x_225; uint8_t x_226; lean_object* x_227; uint8_t x_228; 
+x_224 = lean_ctor_get(x_216, 1);
+x_225 = lean_ctor_get(x_216, 2);
+lean_inc(x_225);
+lean_inc(x_224);
+lean_dec(x_216);
+x_226 = 0;
+x_227 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_227, 0, x_218);
+lean_ctor_set(x_227, 1, x_224);
+lean_ctor_set(x_227, 2, x_225);
+lean_ctor_set(x_227, 3, x_218);
+lean_ctor_set_uint8(x_227, sizeof(void*)*4, x_226);
+x_228 = 1;
+lean_ctor_set(x_1, 0, x_227);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_228);
 return x_1;
 }
 }
 else
 {
-uint8_t x_227; 
-x_227 = !lean_is_exclusive(x_186);
-if (x_227 == 0)
+uint8_t x_229; 
+x_229 = lean_ctor_get_uint8(x_218, sizeof(void*)*4);
+if (x_229 == 0)
 {
-lean_object* x_228; lean_object* x_229; uint8_t x_230; 
-x_228 = lean_ctor_get(x_186, 3);
-lean_dec(x_228);
-x_229 = lean_ctor_get(x_186, 0);
-lean_dec(x_229);
-x_230 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_230);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-else
+uint8_t x_230; 
+x_230 = !lean_is_exclusive(x_216);
+if (x_230 == 0)
 {
-lean_object* x_231; lean_object* x_232; uint8_t x_233; lean_object* x_234; 
-x_231 = lean_ctor_get(x_186, 1);
-x_232 = lean_ctor_get(x_186, 2);
-lean_inc(x_232);
-lean_inc(x_231);
-lean_dec(x_186);
-x_233 = 0;
-x_234 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_234, 0, x_187);
-lean_ctor_set(x_234, 1, x_231);
-lean_ctor_set(x_234, 2, x_232);
-lean_ctor_set(x_234, 3, x_188);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_233);
-lean_ctor_set(x_1, 0, x_234);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_199);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_235; 
-x_235 = lean_ctor_get_uint8(x_187, sizeof(void*)*4);
+lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; uint8_t x_235; 
+x_231 = lean_ctor_get(x_216, 1);
+x_232 = lean_ctor_get(x_216, 2);
+x_233 = lean_ctor_get(x_216, 3);
+lean_dec(x_233);
+x_234 = lean_ctor_get(x_216, 0);
+lean_dec(x_234);
+x_235 = !lean_is_exclusive(x_218);
 if (x_235 == 0)
 {
-uint8_t x_236; 
-x_236 = !lean_is_exclusive(x_186);
-if (x_236 == 0)
-{
-lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; uint8_t x_241; 
-x_237 = lean_ctor_get(x_186, 1);
-x_238 = lean_ctor_get(x_186, 2);
-x_239 = lean_ctor_get(x_186, 3);
-x_240 = lean_ctor_get(x_186, 0);
-lean_dec(x_240);
-x_241 = !lean_is_exclusive(x_187);
-if (x_241 == 0)
-{
-uint8_t x_242; 
-x_242 = 1;
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_242);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_242);
-lean_ctor_set(x_1, 3, x_186);
+lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; uint8_t x_240; uint8_t x_241; 
+x_236 = lean_ctor_get(x_218, 0);
+x_237 = lean_ctor_get(x_218, 1);
+x_238 = lean_ctor_get(x_218, 2);
+x_239 = lean_ctor_get(x_218, 3);
+x_240 = 1;
+lean_ctor_set(x_218, 3, x_236);
+lean_ctor_set(x_218, 2, x_232);
+lean_ctor_set(x_218, 1, x_231);
+lean_ctor_set(x_218, 0, x_217);
+lean_ctor_set_uint8(x_218, sizeof(void*)*4, x_240);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_239);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_240);
+x_241 = 0;
+lean_ctor_set(x_1, 3, x_216);
 lean_ctor_set(x_1, 2, x_238);
 lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_1, 0, x_218);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_241);
 return x_1;
 }
 else
 {
-lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; 
-x_243 = lean_ctor_get(x_187, 0);
-x_244 = lean_ctor_get(x_187, 1);
-x_245 = lean_ctor_get(x_187, 2);
-x_246 = lean_ctor_get(x_187, 3);
-lean_inc(x_246);
+lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; uint8_t x_248; 
+x_242 = lean_ctor_get(x_218, 0);
+x_243 = lean_ctor_get(x_218, 1);
+x_244 = lean_ctor_get(x_218, 2);
+x_245 = lean_ctor_get(x_218, 3);
 lean_inc(x_245);
 lean_inc(x_244);
 lean_inc(x_243);
-lean_dec(x_187);
-x_247 = 1;
-x_248 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_248, 0, x_243);
-lean_ctor_set(x_248, 1, x_244);
-lean_ctor_set(x_248, 2, x_245);
-lean_ctor_set(x_248, 3, x_246);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-lean_ctor_set(x_186, 3, x_38);
-lean_ctor_set(x_186, 2, x_37);
-lean_ctor_set(x_186, 1, x_36);
-lean_ctor_set(x_186, 0, x_239);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_186);
-lean_ctor_set(x_1, 2, x_238);
-lean_ctor_set(x_1, 1, x_237);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_inc(x_242);
+lean_dec(x_218);
+x_246 = 1;
+x_247 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_247, 0, x_217);
+lean_ctor_set(x_247, 1, x_231);
+lean_ctor_set(x_247, 2, x_232);
+lean_ctor_set(x_247, 3, x_242);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_245);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_246);
+x_248 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_244);
+lean_ctor_set(x_1, 1, x_243);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_248);
 return x_1;
 }
 }
 else
 {
-lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; lean_object* x_259; 
-x_249 = lean_ctor_get(x_186, 1);
-x_250 = lean_ctor_get(x_186, 2);
-x_251 = lean_ctor_get(x_186, 3);
-lean_inc(x_251);
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; lean_object* x_257; lean_object* x_258; uint8_t x_259; 
+x_249 = lean_ctor_get(x_216, 1);
+x_250 = lean_ctor_get(x_216, 2);
 lean_inc(x_250);
 lean_inc(x_249);
-lean_dec(x_186);
-x_252 = lean_ctor_get(x_187, 0);
+lean_dec(x_216);
+x_251 = lean_ctor_get(x_218, 0);
+lean_inc(x_251);
+x_252 = lean_ctor_get(x_218, 1);
 lean_inc(x_252);
-x_253 = lean_ctor_get(x_187, 1);
+x_253 = lean_ctor_get(x_218, 2);
 lean_inc(x_253);
-x_254 = lean_ctor_get(x_187, 2);
+x_254 = lean_ctor_get(x_218, 3);
 lean_inc(x_254);
-x_255 = lean_ctor_get(x_187, 3);
-lean_inc(x_255);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_256 = x_187;
+if (lean_is_exclusive(x_218)) {
+ lean_ctor_release(x_218, 0);
+ lean_ctor_release(x_218, 1);
+ lean_ctor_release(x_218, 2);
+ lean_ctor_release(x_218, 3);
+ x_255 = x_218;
 } else {
- lean_dec_ref(x_187);
- x_256 = lean_box(0);
+ lean_dec_ref(x_218);
+ x_255 = lean_box(0);
 }
-x_257 = 1;
-if (lean_is_scalar(x_256)) {
- x_258 = lean_alloc_ctor(1, 4, 1);
+x_256 = 1;
+if (lean_is_scalar(x_255)) {
+ x_257 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_258 = x_256;
+ x_257 = x_255;
 }
-lean_ctor_set(x_258, 0, x_252);
-lean_ctor_set(x_258, 1, x_253);
-lean_ctor_set(x_258, 2, x_254);
-lean_ctor_set(x_258, 3, x_255);
-lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
-x_259 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_259, 0, x_251);
-lean_ctor_set(x_259, 1, x_36);
-lean_ctor_set(x_259, 2, x_37);
-lean_ctor_set(x_259, 3, x_38);
-lean_ctor_set_uint8(x_259, sizeof(void*)*4, x_257);
-lean_ctor_set(x_1, 3, x_259);
-lean_ctor_set(x_1, 2, x_250);
-lean_ctor_set(x_1, 1, x_249);
-lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set(x_257, 0, x_217);
+lean_ctor_set(x_257, 1, x_249);
+lean_ctor_set(x_257, 2, x_250);
+lean_ctor_set(x_257, 3, x_251);
+lean_ctor_set_uint8(x_257, sizeof(void*)*4, x_256);
+x_258 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_258, 0, x_254);
+lean_ctor_set(x_258, 1, x_43);
+lean_ctor_set(x_258, 2, x_44);
+lean_ctor_set(x_258, 3, x_45);
+lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_256);
+x_259 = 0;
+lean_ctor_set(x_1, 3, x_258);
+lean_ctor_set(x_1, 2, x_253);
+lean_ctor_set(x_1, 1, x_252);
+lean_ctor_set(x_1, 0, x_257);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
 return x_1;
 }
 }
 else
 {
-lean_object* x_260; 
-x_260 = lean_ctor_get(x_186, 3);
-lean_inc(x_260);
-if (lean_obj_tag(x_260) == 0)
+uint8_t x_260; 
+x_260 = !lean_is_exclusive(x_216);
+if (x_260 == 0)
 {
-uint8_t x_261; 
-x_261 = !lean_is_exclusive(x_186);
-if (x_261 == 0)
-{
-lean_object* x_262; lean_object* x_263; uint8_t x_264; 
-x_262 = lean_ctor_get(x_186, 3);
+lean_object* x_261; lean_object* x_262; uint8_t x_263; uint8_t x_264; 
+x_261 = lean_ctor_get(x_216, 3);
+lean_dec(x_261);
+x_262 = lean_ctor_get(x_216, 0);
 lean_dec(x_262);
-x_263 = lean_ctor_get(x_186, 0);
-lean_dec(x_263);
-x_264 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_264);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+x_263 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_263);
+x_264 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_264);
 return x_1;
 }
 else
 {
-lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; 
-x_265 = lean_ctor_get(x_186, 1);
-x_266 = lean_ctor_get(x_186, 2);
+lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; uint8_t x_269; 
+x_265 = lean_ctor_get(x_216, 1);
+x_266 = lean_ctor_get(x_216, 2);
 lean_inc(x_266);
 lean_inc(x_265);
-lean_dec(x_186);
+lean_dec(x_216);
 x_267 = 0;
 x_268 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_268, 0, x_187);
+lean_ctor_set(x_268, 0, x_217);
 lean_ctor_set(x_268, 1, x_265);
 lean_ctor_set(x_268, 2, x_266);
-lean_ctor_set(x_268, 3, x_260);
+lean_ctor_set(x_268, 3, x_218);
 lean_ctor_set_uint8(x_268, sizeof(void*)*4, x_267);
+x_269 = 1;
 lean_ctor_set(x_1, 0, x_268);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_235);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_270; 
+x_270 = lean_ctor_get_uint8(x_217, sizeof(void*)*4);
+if (x_270 == 0)
+{
+uint8_t x_271; 
+x_271 = !lean_is_exclusive(x_216);
+if (x_271 == 0)
+{
+lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; uint8_t x_276; 
+x_272 = lean_ctor_get(x_216, 1);
+x_273 = lean_ctor_get(x_216, 2);
+x_274 = lean_ctor_get(x_216, 3);
+x_275 = lean_ctor_get(x_216, 0);
+lean_dec(x_275);
+x_276 = !lean_is_exclusive(x_217);
+if (x_276 == 0)
+{
+uint8_t x_277; uint8_t x_278; 
+x_277 = 1;
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_277);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_277);
+x_278 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_278);
+return x_1;
+}
+else
+{
+lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; uint8_t x_283; lean_object* x_284; uint8_t x_285; 
+x_279 = lean_ctor_get(x_217, 0);
+x_280 = lean_ctor_get(x_217, 1);
+x_281 = lean_ctor_get(x_217, 2);
+x_282 = lean_ctor_get(x_217, 3);
+lean_inc(x_282);
+lean_inc(x_281);
+lean_inc(x_280);
+lean_inc(x_279);
+lean_dec(x_217);
+x_283 = 1;
+x_284 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_284, 0, x_279);
+lean_ctor_set(x_284, 1, x_280);
+lean_ctor_set(x_284, 2, x_281);
+lean_ctor_set(x_284, 3, x_282);
+lean_ctor_set_uint8(x_284, sizeof(void*)*4, x_283);
+lean_ctor_set(x_216, 3, x_45);
+lean_ctor_set(x_216, 2, x_44);
+lean_ctor_set(x_216, 1, x_43);
+lean_ctor_set(x_216, 0, x_274);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_283);
+x_285 = 0;
+lean_ctor_set(x_1, 3, x_216);
+lean_ctor_set(x_1, 2, x_273);
+lean_ctor_set(x_1, 1, x_272);
+lean_ctor_set(x_1, 0, x_284);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_285);
 return x_1;
 }
 }
 else
 {
-uint8_t x_269; 
-x_269 = lean_ctor_get_uint8(x_260, sizeof(void*)*4);
-if (x_269 == 0)
-{
-uint8_t x_270; 
-lean_free_object(x_1);
-x_270 = !lean_is_exclusive(x_186);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; uint8_t x_275; 
-x_271 = lean_ctor_get(x_186, 1);
-x_272 = lean_ctor_get(x_186, 2);
-x_273 = lean_ctor_get(x_186, 3);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_186, 0);
-lean_dec(x_274);
-x_275 = !lean_is_exclusive(x_260);
-if (x_275 == 0)
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; uint8_t x_280; 
-x_276 = lean_ctor_get(x_260, 0);
-x_277 = lean_ctor_get(x_260, 1);
-x_278 = lean_ctor_get(x_260, 2);
-x_279 = lean_ctor_get(x_260, 3);
-lean_inc(x_187);
-lean_ctor_set(x_260, 3, x_276);
-lean_ctor_set(x_260, 2, x_272);
-lean_ctor_set(x_260, 1, x_271);
-lean_ctor_set(x_260, 0, x_187);
-x_280 = !lean_is_exclusive(x_187);
-if (x_280 == 0)
-{
-lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; 
-x_281 = lean_ctor_get(x_187, 3);
-lean_dec(x_281);
-x_282 = lean_ctor_get(x_187, 2);
-lean_dec(x_282);
-x_283 = lean_ctor_get(x_187, 1);
-lean_dec(x_283);
-x_284 = lean_ctor_get(x_187, 0);
-lean_dec(x_284);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-lean_ctor_set(x_187, 3, x_38);
-lean_ctor_set(x_187, 2, x_37);
-lean_ctor_set(x_187, 1, x_36);
-lean_ctor_set(x_187, 0, x_279);
-lean_ctor_set(x_186, 3, x_187);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-else
-{
-lean_object* x_285; 
-lean_dec(x_187);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_235);
-x_285 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_285, 0, x_279);
-lean_ctor_set(x_285, 1, x_36);
-lean_ctor_set(x_285, 2, x_37);
-lean_ctor_set(x_285, 3, x_38);
-lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_285);
-lean_ctor_set(x_186, 2, x_278);
-lean_ctor_set(x_186, 1, x_277);
-lean_ctor_set(x_186, 0, x_260);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
-}
-}
-else
-{
-lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; 
-x_286 = lean_ctor_get(x_260, 0);
-x_287 = lean_ctor_get(x_260, 1);
-x_288 = lean_ctor_get(x_260, 2);
-x_289 = lean_ctor_get(x_260, 3);
-lean_inc(x_289);
+lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; uint8_t x_294; lean_object* x_295; lean_object* x_296; uint8_t x_297; 
+x_286 = lean_ctor_get(x_216, 1);
+x_287 = lean_ctor_get(x_216, 2);
+x_288 = lean_ctor_get(x_216, 3);
 lean_inc(x_288);
 lean_inc(x_287);
 lean_inc(x_286);
-lean_dec(x_260);
-lean_inc(x_187);
-x_290 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_290, 0, x_187);
-lean_ctor_set(x_290, 1, x_271);
-lean_ctor_set(x_290, 2, x_272);
-lean_ctor_set(x_290, 3, x_286);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_291 = x_187;
+lean_dec(x_216);
+x_289 = lean_ctor_get(x_217, 0);
+lean_inc(x_289);
+x_290 = lean_ctor_get(x_217, 1);
+lean_inc(x_290);
+x_291 = lean_ctor_get(x_217, 2);
+lean_inc(x_291);
+x_292 = lean_ctor_get(x_217, 3);
+lean_inc(x_292);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_293 = x_217;
 } else {
- lean_dec_ref(x_187);
- x_291 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_293 = lean_box(0);
 }
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
+x_294 = 1;
+if (lean_is_scalar(x_293)) {
+ x_295 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_292 = x_291;
+ x_295 = x_293;
 }
-lean_ctor_set(x_292, 0, x_289);
-lean_ctor_set(x_292, 1, x_36);
-lean_ctor_set(x_292, 2, x_37);
-lean_ctor_set(x_292, 3, x_38);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_235);
-lean_ctor_set(x_186, 3, x_292);
-lean_ctor_set(x_186, 2, x_288);
-lean_ctor_set(x_186, 1, x_287);
-lean_ctor_set(x_186, 0, x_290);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_269);
-return x_186;
+lean_ctor_set(x_295, 0, x_289);
+lean_ctor_set(x_295, 1, x_290);
+lean_ctor_set(x_295, 2, x_291);
+lean_ctor_set(x_295, 3, x_292);
+lean_ctor_set_uint8(x_295, sizeof(void*)*4, x_294);
+x_296 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_296, 0, x_288);
+lean_ctor_set(x_296, 1, x_43);
+lean_ctor_set(x_296, 2, x_44);
+lean_ctor_set(x_296, 3, x_45);
+lean_ctor_set_uint8(x_296, sizeof(void*)*4, x_294);
+x_297 = 0;
+lean_ctor_set(x_1, 3, x_296);
+lean_ctor_set(x_1, 2, x_287);
+lean_ctor_set(x_1, 1, x_286);
+lean_ctor_set(x_1, 0, x_295);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_297);
+return x_1;
 }
 }
 else
 {
-lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; 
-x_293 = lean_ctor_get(x_186, 1);
-x_294 = lean_ctor_get(x_186, 2);
-lean_inc(x_294);
-lean_inc(x_293);
-lean_dec(x_186);
-x_295 = lean_ctor_get(x_260, 0);
-lean_inc(x_295);
-x_296 = lean_ctor_get(x_260, 1);
-lean_inc(x_296);
-x_297 = lean_ctor_get(x_260, 2);
-lean_inc(x_297);
-x_298 = lean_ctor_get(x_260, 3);
+lean_object* x_298; 
+x_298 = lean_ctor_get(x_216, 3);
 lean_inc(x_298);
-if (lean_is_exclusive(x_260)) {
- lean_ctor_release(x_260, 0);
- lean_ctor_release(x_260, 1);
- lean_ctor_release(x_260, 2);
- lean_ctor_release(x_260, 3);
- x_299 = x_260;
-} else {
- lean_dec_ref(x_260);
- x_299 = lean_box(0);
-}
-lean_inc(x_187);
-if (lean_is_scalar(x_299)) {
- x_300 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_300 = x_299;
-}
-lean_ctor_set(x_300, 0, x_187);
-lean_ctor_set(x_300, 1, x_293);
-lean_ctor_set(x_300, 2, x_294);
-lean_ctor_set(x_300, 3, x_295);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_301 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_301 = lean_box(0);
-}
-lean_ctor_set_uint8(x_300, sizeof(void*)*4, x_235);
-if (lean_is_scalar(x_301)) {
- x_302 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_302 = x_301;
-}
-lean_ctor_set(x_302, 0, x_298);
-lean_ctor_set(x_302, 1, x_36);
-lean_ctor_set(x_302, 2, x_37);
-lean_ctor_set(x_302, 3, x_38);
-lean_ctor_set_uint8(x_302, sizeof(void*)*4, x_235);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_300);
-lean_ctor_set(x_303, 1, x_296);
-lean_ctor_set(x_303, 2, x_297);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_269);
-return x_303;
-}
-}
-else
+if (lean_obj_tag(x_298) == 0)
 {
-uint8_t x_304; 
-x_304 = !lean_is_exclusive(x_186);
-if (x_304 == 0)
+uint8_t x_299; 
+x_299 = !lean_is_exclusive(x_216);
+if (x_299 == 0)
 {
-lean_object* x_305; lean_object* x_306; uint8_t x_307; 
-x_305 = lean_ctor_get(x_186, 3);
-lean_dec(x_305);
-x_306 = lean_ctor_get(x_186, 0);
-lean_dec(x_306);
-x_307 = !lean_is_exclusive(x_187);
-if (x_307 == 0)
-{
-uint8_t x_308; 
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_269);
-x_308 = 0;
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_308);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_300; lean_object* x_301; uint8_t x_302; uint8_t x_303; 
+x_300 = lean_ctor_get(x_216, 3);
+lean_dec(x_300);
+x_301 = lean_ctor_get(x_216, 0);
+lean_dec(x_301);
+x_302 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_302);
+x_303 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_303);
 return x_1;
 }
 else
 {
-lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; uint8_t x_314; 
-x_309 = lean_ctor_get(x_187, 0);
-x_310 = lean_ctor_get(x_187, 1);
-x_311 = lean_ctor_get(x_187, 2);
-x_312 = lean_ctor_get(x_187, 3);
-lean_inc(x_312);
-lean_inc(x_311);
-lean_inc(x_310);
-lean_inc(x_309);
-lean_dec(x_187);
-x_313 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_313, 0, x_309);
-lean_ctor_set(x_313, 1, x_310);
-lean_ctor_set(x_313, 2, x_311);
-lean_ctor_set(x_313, 3, x_312);
-lean_ctor_set_uint8(x_313, sizeof(void*)*4, x_269);
-x_314 = 0;
-lean_ctor_set(x_186, 0, x_313);
-lean_ctor_set_uint8(x_186, sizeof(void*)*4, x_314);
-lean_ctor_set(x_1, 0, x_186);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
+lean_object* x_304; lean_object* x_305; uint8_t x_306; lean_object* x_307; uint8_t x_308; 
+x_304 = lean_ctor_get(x_216, 1);
+x_305 = lean_ctor_get(x_216, 2);
+lean_inc(x_305);
+lean_inc(x_304);
+lean_dec(x_216);
+x_306 = 0;
+x_307 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_307, 0, x_217);
+lean_ctor_set(x_307, 1, x_304);
+lean_ctor_set(x_307, 2, x_305);
+lean_ctor_set(x_307, 3, x_298);
+lean_ctor_set_uint8(x_307, sizeof(void*)*4, x_306);
+x_308 = 1;
+lean_ctor_set(x_1, 0, x_307);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_308);
 return x_1;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; 
-x_315 = lean_ctor_get(x_186, 1);
-x_316 = lean_ctor_get(x_186, 2);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_186);
-x_317 = lean_ctor_get(x_187, 0);
-lean_inc(x_317);
-x_318 = lean_ctor_get(x_187, 1);
-lean_inc(x_318);
-x_319 = lean_ctor_get(x_187, 2);
-lean_inc(x_319);
-x_320 = lean_ctor_get(x_187, 3);
-lean_inc(x_320);
-if (lean_is_exclusive(x_187)) {
- lean_ctor_release(x_187, 0);
- lean_ctor_release(x_187, 1);
- lean_ctor_release(x_187, 2);
- lean_ctor_release(x_187, 3);
- x_321 = x_187;
-} else {
- lean_dec_ref(x_187);
- x_321 = lean_box(0);
-}
-if (lean_is_scalar(x_321)) {
- x_322 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_322 = x_321;
-}
-lean_ctor_set(x_322, 0, x_317);
-lean_ctor_set(x_322, 1, x_318);
-lean_ctor_set(x_322, 2, x_319);
-lean_ctor_set(x_322, 3, x_320);
-lean_ctor_set_uint8(x_322, sizeof(void*)*4, x_269);
-x_323 = 0;
-x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_322);
-lean_ctor_set(x_324, 1, x_315);
-lean_ctor_set(x_324, 2, x_316);
-lean_ctor_set(x_324, 3, x_260);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
-lean_ctor_set(x_1, 0, x_324);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_269);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_309; 
+x_309 = lean_ctor_get_uint8(x_298, sizeof(void*)*4);
+if (x_309 == 0)
+{
+uint8_t x_310; 
+lean_free_object(x_1);
+x_310 = !lean_is_exclusive(x_216);
+if (x_310 == 0)
+{
+lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; uint8_t x_315; 
+x_311 = lean_ctor_get(x_216, 1);
+x_312 = lean_ctor_get(x_216, 2);
+x_313 = lean_ctor_get(x_216, 3);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_216, 0);
+lean_dec(x_314);
+x_315 = !lean_is_exclusive(x_298);
+if (x_315 == 0)
+{
+lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; uint8_t x_320; uint8_t x_321; 
+x_316 = lean_ctor_get(x_298, 0);
+x_317 = lean_ctor_get(x_298, 1);
+x_318 = lean_ctor_get(x_298, 2);
+x_319 = lean_ctor_get(x_298, 3);
+x_320 = 1;
+lean_inc(x_217);
+lean_ctor_set(x_298, 3, x_316);
+lean_ctor_set(x_298, 2, x_312);
+lean_ctor_set(x_298, 1, x_311);
+lean_ctor_set(x_298, 0, x_217);
+x_321 = !lean_is_exclusive(x_217);
+if (x_321 == 0)
+{
+lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; uint8_t x_326; 
+x_322 = lean_ctor_get(x_217, 3);
+lean_dec(x_322);
+x_323 = lean_ctor_get(x_217, 2);
+lean_dec(x_323);
+x_324 = lean_ctor_get(x_217, 1);
+lean_dec(x_324);
+x_325 = lean_ctor_get(x_217, 0);
+lean_dec(x_325);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+lean_ctor_set(x_217, 3, x_45);
+lean_ctor_set(x_217, 2, x_44);
+lean_ctor_set(x_217, 1, x_43);
+lean_ctor_set(x_217, 0, x_319);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_320);
+x_326 = 0;
+lean_ctor_set(x_216, 3, x_217);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_326);
+return x_216;
 }
+else
+{
+lean_object* x_327; uint8_t x_328; 
+lean_dec(x_217);
+lean_ctor_set_uint8(x_298, sizeof(void*)*4, x_320);
+x_327 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_327, 0, x_319);
+lean_ctor_set(x_327, 1, x_43);
+lean_ctor_set(x_327, 2, x_44);
+lean_ctor_set(x_327, 3, x_45);
+lean_ctor_set_uint8(x_327, sizeof(void*)*4, x_320);
+x_328 = 0;
+lean_ctor_set(x_216, 3, x_327);
+lean_ctor_set(x_216, 2, x_318);
+lean_ctor_set(x_216, 1, x_317);
+lean_ctor_set(x_216, 0, x_298);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_328);
+return x_216;
 }
 }
 else
 {
-lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; uint32_t x_329; uint8_t x_330; 
-x_325 = lean_ctor_get(x_1, 0);
-x_326 = lean_ctor_get(x_1, 1);
-x_327 = lean_ctor_get(x_1, 2);
-x_328 = lean_ctor_get(x_1, 3);
-lean_inc(x_328);
-lean_inc(x_327);
-lean_inc(x_326);
-lean_inc(x_325);
-lean_dec(x_1);
-x_329 = lean_unbox_uint32(x_326);
-x_330 = x_2 < x_329;
-if (x_330 == 0)
-{
-uint32_t x_331; uint8_t x_332; 
-x_331 = lean_unbox_uint32(x_326);
-x_332 = x_331 < x_2;
-if (x_332 == 0)
-{
-lean_object* x_333; lean_object* x_334; 
-lean_dec(x_327);
-lean_dec(x_326);
-x_333 = lean_box_uint32(x_2);
+lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; uint8_t x_337; 
+x_329 = lean_ctor_get(x_298, 0);
+x_330 = lean_ctor_get(x_298, 1);
+x_331 = lean_ctor_get(x_298, 2);
+x_332 = lean_ctor_get(x_298, 3);
+lean_inc(x_332);
+lean_inc(x_331);
+lean_inc(x_330);
+lean_inc(x_329);
+lean_dec(x_298);
+x_333 = 1;
+lean_inc(x_217);
 x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_325);
-lean_ctor_set(x_334, 1, x_333);
-lean_ctor_set(x_334, 2, x_3);
-lean_ctor_set(x_334, 3, x_328);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_7);
-return x_334;
+lean_ctor_set(x_334, 0, x_217);
+lean_ctor_set(x_334, 1, x_311);
+lean_ctor_set(x_334, 2, x_312);
+lean_ctor_set(x_334, 3, x_329);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_335 = x_217;
+} else {
+ lean_dec_ref(x_217);
+ x_335 = lean_box(0);
+}
+lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
+if (lean_is_scalar(x_335)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_336 = x_335;
+}
+lean_ctor_set(x_336, 0, x_332);
+lean_ctor_set(x_336, 1, x_43);
+lean_ctor_set(x_336, 2, x_44);
+lean_ctor_set(x_336, 3, x_45);
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_333);
+x_337 = 0;
+lean_ctor_set(x_216, 3, x_336);
+lean_ctor_set(x_216, 2, x_331);
+lean_ctor_set(x_216, 1, x_330);
+lean_ctor_set(x_216, 0, x_334);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_337);
+return x_216;
+}
 }
 else
 {
-uint8_t x_335; 
-x_335 = l_Std_RBNode_isRed___rarg(x_328);
-if (x_335 == 0)
-{
-lean_object* x_336; lean_object* x_337; 
-x_336 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_328, x_2, x_3);
-x_337 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_337, 0, x_325);
-lean_ctor_set(x_337, 1, x_326);
-lean_ctor_set(x_337, 2, x_327);
-lean_ctor_set(x_337, 3, x_336);
-lean_ctor_set_uint8(x_337, sizeof(void*)*4, x_7);
-return x_337;
-}
-else
-{
-lean_object* x_338; lean_object* x_339; 
-x_338 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_328, x_2, x_3);
-x_339 = lean_ctor_get(x_338, 0);
+lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; uint8_t x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; uint8_t x_349; lean_object* x_350; 
+x_338 = lean_ctor_get(x_216, 1);
+x_339 = lean_ctor_get(x_216, 2);
 lean_inc(x_339);
-if (lean_obj_tag(x_339) == 0)
-{
-lean_object* x_340; 
-x_340 = lean_ctor_get(x_338, 3);
+lean_inc(x_338);
+lean_dec(x_216);
+x_340 = lean_ctor_get(x_298, 0);
 lean_inc(x_340);
-if (lean_obj_tag(x_340) == 0)
-{
-lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; uint8_t x_346; lean_object* x_347; 
-x_341 = lean_ctor_get(x_338, 1);
+x_341 = lean_ctor_get(x_298, 1);
 lean_inc(x_341);
-x_342 = lean_ctor_get(x_338, 2);
+x_342 = lean_ctor_get(x_298, 2);
 lean_inc(x_342);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_343 = x_338;
+x_343 = lean_ctor_get(x_298, 3);
+lean_inc(x_343);
+if (lean_is_exclusive(x_298)) {
+ lean_ctor_release(x_298, 0);
+ lean_ctor_release(x_298, 1);
+ lean_ctor_release(x_298, 2);
+ lean_ctor_release(x_298, 3);
+ x_344 = x_298;
 } else {
- lean_dec_ref(x_338);
- x_343 = lean_box(0);
+ lean_dec_ref(x_298);
+ x_344 = lean_box(0);
 }
-x_344 = 0;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
+x_345 = 1;
+lean_inc(x_217);
+if (lean_is_scalar(x_344)) {
+ x_346 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_345 = x_343;
+ x_346 = x_344;
 }
-lean_ctor_set(x_345, 0, x_340);
-lean_ctor_set(x_345, 1, x_341);
-lean_ctor_set(x_345, 2, x_342);
-lean_ctor_set(x_345, 3, x_340);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-x_346 = 1;
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_325);
-lean_ctor_set(x_347, 1, x_326);
-lean_ctor_set(x_347, 2, x_327);
-lean_ctor_set(x_347, 3, x_345);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_346);
-return x_347;
-}
-else
-{
-uint8_t x_348; 
-x_348 = lean_ctor_get_uint8(x_340, sizeof(void*)*4);
-if (x_348 == 0)
-{
-lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; uint8_t x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; 
-x_349 = lean_ctor_get(x_338, 1);
-lean_inc(x_349);
-x_350 = lean_ctor_get(x_338, 2);
-lean_inc(x_350);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_351 = x_338;
+lean_ctor_set(x_346, 0, x_217);
+lean_ctor_set(x_346, 1, x_338);
+lean_ctor_set(x_346, 2, x_339);
+lean_ctor_set(x_346, 3, x_340);
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_347 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_351 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_347 = lean_box(0);
 }
-x_352 = lean_ctor_get(x_340, 0);
-lean_inc(x_352);
-x_353 = lean_ctor_get(x_340, 1);
-lean_inc(x_353);
-x_354 = lean_ctor_get(x_340, 2);
-lean_inc(x_354);
-x_355 = lean_ctor_get(x_340, 3);
-lean_inc(x_355);
-if (lean_is_exclusive(x_340)) {
- lean_ctor_release(x_340, 0);
- lean_ctor_release(x_340, 1);
- lean_ctor_release(x_340, 2);
- lean_ctor_release(x_340, 3);
- x_356 = x_340;
+lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_345);
+if (lean_is_scalar(x_347)) {
+ x_348 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_340);
- x_356 = lean_box(0);
-}
-x_357 = 1;
-if (lean_is_scalar(x_356)) {
- x_358 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_358 = x_356;
-}
-lean_ctor_set(x_358, 0, x_325);
-lean_ctor_set(x_358, 1, x_326);
-lean_ctor_set(x_358, 2, x_327);
-lean_ctor_set(x_358, 3, x_339);
-lean_ctor_set_uint8(x_358, sizeof(void*)*4, x_357);
-if (lean_is_scalar(x_351)) {
- x_359 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_359 = x_351;
-}
-lean_ctor_set(x_359, 0, x_352);
-lean_ctor_set(x_359, 1, x_353);
-lean_ctor_set(x_359, 2, x_354);
-lean_ctor_set(x_359, 3, x_355);
-lean_ctor_set_uint8(x_359, sizeof(void*)*4, x_357);
-x_360 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_360, 0, x_358);
-lean_ctor_set(x_360, 1, x_349);
-lean_ctor_set(x_360, 2, x_350);
-lean_ctor_set(x_360, 3, x_359);
-lean_ctor_set_uint8(x_360, sizeof(void*)*4, x_348);
-return x_360;
-}
-else
-{
-lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; 
-x_361 = lean_ctor_get(x_338, 1);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_338, 2);
-lean_inc(x_362);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_363 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_363 = lean_box(0);
-}
-x_364 = 0;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
-}
-lean_ctor_set(x_365, 0, x_339);
-lean_ctor_set(x_365, 1, x_361);
-lean_ctor_set(x_365, 2, x_362);
-lean_ctor_set(x_365, 3, x_340);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-x_366 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_366, 0, x_325);
-lean_ctor_set(x_366, 1, x_326);
-lean_ctor_set(x_366, 2, x_327);
-lean_ctor_set(x_366, 3, x_365);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_348);
-return x_366;
+ x_348 = x_347;
 }
+lean_ctor_set(x_348, 0, x_343);
+lean_ctor_set(x_348, 1, x_43);
+lean_ctor_set(x_348, 2, x_44);
+lean_ctor_set(x_348, 3, x_45);
+lean_ctor_set_uint8(x_348, sizeof(void*)*4, x_345);
+x_349 = 0;
+x_350 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_350, 0, x_346);
+lean_ctor_set(x_350, 1, x_341);
+lean_ctor_set(x_350, 2, x_342);
+lean_ctor_set(x_350, 3, x_348);
+lean_ctor_set_uint8(x_350, sizeof(void*)*4, x_349);
+return x_350;
 }
 }
 else
 {
-uint8_t x_367; 
-x_367 = lean_ctor_get_uint8(x_339, sizeof(void*)*4);
-if (x_367 == 0)
+uint8_t x_351; 
+x_351 = !lean_is_exclusive(x_216);
+if (x_351 == 0)
 {
-lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; uint8_t x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; 
-x_368 = lean_ctor_get(x_338, 1);
+lean_object* x_352; lean_object* x_353; uint8_t x_354; 
+x_352 = lean_ctor_get(x_216, 3);
+lean_dec(x_352);
+x_353 = lean_ctor_get(x_216, 0);
+lean_dec(x_353);
+x_354 = !lean_is_exclusive(x_217);
+if (x_354 == 0)
+{
+uint8_t x_355; uint8_t x_356; 
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_309);
+x_355 = 0;
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_355);
+x_356 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_356);
+return x_1;
+}
+else
+{
+lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; uint8_t x_363; 
+x_357 = lean_ctor_get(x_217, 0);
+x_358 = lean_ctor_get(x_217, 1);
+x_359 = lean_ctor_get(x_217, 2);
+x_360 = lean_ctor_get(x_217, 3);
+lean_inc(x_360);
+lean_inc(x_359);
+lean_inc(x_358);
+lean_inc(x_357);
+lean_dec(x_217);
+x_361 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_361, 0, x_357);
+lean_ctor_set(x_361, 1, x_358);
+lean_ctor_set(x_361, 2, x_359);
+lean_ctor_set(x_361, 3, x_360);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_309);
+x_362 = 0;
+lean_ctor_set(x_216, 0, x_361);
+lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_362);
+x_363 = 1;
+lean_ctor_set(x_1, 0, x_216);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_363);
+return x_1;
+}
+}
+else
+{
+lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; uint8_t x_374; 
+x_364 = lean_ctor_get(x_216, 1);
+x_365 = lean_ctor_get(x_216, 2);
+lean_inc(x_365);
+lean_inc(x_364);
+lean_dec(x_216);
+x_366 = lean_ctor_get(x_217, 0);
+lean_inc(x_366);
+x_367 = lean_ctor_get(x_217, 1);
+lean_inc(x_367);
+x_368 = lean_ctor_get(x_217, 2);
 lean_inc(x_368);
-x_369 = lean_ctor_get(x_338, 2);
+x_369 = lean_ctor_get(x_217, 3);
 lean_inc(x_369);
-x_370 = lean_ctor_get(x_338, 3);
-lean_inc(x_370);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_371 = x_338;
+if (lean_is_exclusive(x_217)) {
+ lean_ctor_release(x_217, 0);
+ lean_ctor_release(x_217, 1);
+ lean_ctor_release(x_217, 2);
+ lean_ctor_release(x_217, 3);
+ x_370 = x_217;
 } else {
- lean_dec_ref(x_338);
- x_371 = lean_box(0);
+ lean_dec_ref(x_217);
+ x_370 = lean_box(0);
 }
-x_372 = lean_ctor_get(x_339, 0);
-lean_inc(x_372);
-x_373 = lean_ctor_get(x_339, 1);
-lean_inc(x_373);
-x_374 = lean_ctor_get(x_339, 2);
-lean_inc(x_374);
-x_375 = lean_ctor_get(x_339, 3);
+if (lean_is_scalar(x_370)) {
+ x_371 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_371 = x_370;
+}
+lean_ctor_set(x_371, 0, x_366);
+lean_ctor_set(x_371, 1, x_367);
+lean_ctor_set(x_371, 2, x_368);
+lean_ctor_set(x_371, 3, x_369);
+lean_ctor_set_uint8(x_371, sizeof(void*)*4, x_309);
+x_372 = 0;
+x_373 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_373, 0, x_371);
+lean_ctor_set(x_373, 1, x_364);
+lean_ctor_set(x_373, 2, x_365);
+lean_ctor_set(x_373, 3, x_298);
+lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
+x_374 = 1;
+lean_ctor_set(x_1, 0, x_373);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_374);
+return x_1;
+}
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; uint32_t x_379; uint8_t x_380; 
+x_375 = lean_ctor_get(x_1, 0);
+x_376 = lean_ctor_get(x_1, 1);
+x_377 = lean_ctor_get(x_1, 2);
+x_378 = lean_ctor_get(x_1, 3);
+lean_inc(x_378);
+lean_inc(x_377);
+lean_inc(x_376);
 lean_inc(x_375);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_376 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_376 = lean_box(0);
-}
-x_377 = 1;
-if (lean_is_scalar(x_376)) {
- x_378 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_378 = x_376;
-}
-lean_ctor_set(x_378, 0, x_325);
-lean_ctor_set(x_378, 1, x_326);
-lean_ctor_set(x_378, 2, x_327);
-lean_ctor_set(x_378, 3, x_372);
-lean_ctor_set_uint8(x_378, sizeof(void*)*4, x_377);
-if (lean_is_scalar(x_371)) {
- x_379 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_379 = x_371;
-}
-lean_ctor_set(x_379, 0, x_375);
-lean_ctor_set(x_379, 1, x_368);
-lean_ctor_set(x_379, 2, x_369);
-lean_ctor_set(x_379, 3, x_370);
-lean_ctor_set_uint8(x_379, sizeof(void*)*4, x_377);
-x_380 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_380, 0, x_378);
-lean_ctor_set(x_380, 1, x_373);
-lean_ctor_set(x_380, 2, x_374);
-lean_ctor_set(x_380, 3, x_379);
-lean_ctor_set_uint8(x_380, sizeof(void*)*4, x_367);
-return x_380;
+lean_dec(x_1);
+x_379 = lean_unbox_uint32(x_376);
+x_380 = x_2 < x_379;
+if (x_380 == 0)
+{
+uint32_t x_381; uint8_t x_382; 
+x_381 = lean_unbox_uint32(x_376);
+x_382 = x_381 < x_2;
+if (x_382 == 0)
+{
+uint8_t x_383; lean_object* x_384; lean_object* x_385; 
+lean_dec(x_377);
+lean_dec(x_376);
+x_383 = 1;
+x_384 = lean_box_uint32(x_2);
+x_385 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_385, 0, x_375);
+lean_ctor_set(x_385, 1, x_384);
+lean_ctor_set(x_385, 2, x_3);
+lean_ctor_set(x_385, 3, x_378);
+lean_ctor_set_uint8(x_385, sizeof(void*)*4, x_383);
+return x_385;
 }
 else
 {
-lean_object* x_381; 
-x_381 = lean_ctor_get(x_338, 3);
-lean_inc(x_381);
-if (lean_obj_tag(x_381) == 0)
+uint8_t x_386; 
+x_386 = l_Std_RBNode_isRed___rarg(x_378);
+if (x_386 == 0)
 {
-lean_object* x_382; lean_object* x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; lean_object* x_387; 
-x_382 = lean_ctor_get(x_338, 1);
-lean_inc(x_382);
-x_383 = lean_ctor_get(x_338, 2);
-lean_inc(x_383);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_384 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_384 = lean_box(0);
-}
-x_385 = 0;
-if (lean_is_scalar(x_384)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_384;
-}
-lean_ctor_set(x_386, 0, x_339);
-lean_ctor_set(x_386, 1, x_382);
-lean_ctor_set(x_386, 2, x_383);
-lean_ctor_set(x_386, 3, x_381);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
-x_387 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_387, 0, x_325);
-lean_ctor_set(x_387, 1, x_326);
-lean_ctor_set(x_387, 2, x_327);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_367);
-return x_387;
+lean_object* x_387; uint8_t x_388; lean_object* x_389; 
+x_387 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_378, x_2, x_3);
+x_388 = 1;
+x_389 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_389, 0, x_375);
+lean_ctor_set(x_389, 1, x_376);
+lean_ctor_set(x_389, 2, x_377);
+lean_ctor_set(x_389, 3, x_387);
+lean_ctor_set_uint8(x_389, sizeof(void*)*4, x_388);
+return x_389;
 }
 else
 {
-uint8_t x_388; 
-x_388 = lean_ctor_get_uint8(x_381, sizeof(void*)*4);
-if (x_388 == 0)
+lean_object* x_390; lean_object* x_391; 
+x_390 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_378, x_2, x_3);
+x_391 = lean_ctor_get(x_390, 0);
+lean_inc(x_391);
+if (lean_obj_tag(x_391) == 0)
 {
-lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; 
-x_389 = lean_ctor_get(x_338, 1);
-lean_inc(x_389);
-x_390 = lean_ctor_get(x_338, 2);
-lean_inc(x_390);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_391 = x_338;
-} else {
- lean_dec_ref(x_338);
- x_391 = lean_box(0);
-}
-x_392 = lean_ctor_get(x_381, 0);
+lean_object* x_392; 
+x_392 = lean_ctor_get(x_390, 3);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_381, 1);
+if (lean_obj_tag(x_392) == 0)
+{
+lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; uint8_t x_398; lean_object* x_399; 
+x_393 = lean_ctor_get(x_390, 1);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_381, 2);
+x_394 = lean_ctor_get(x_390, 2);
 lean_inc(x_394);
-x_395 = lean_ctor_get(x_381, 3);
-lean_inc(x_395);
-if (lean_is_exclusive(x_381)) {
- lean_ctor_release(x_381, 0);
- lean_ctor_release(x_381, 1);
- lean_ctor_release(x_381, 2);
- lean_ctor_release(x_381, 3);
- x_396 = x_381;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_395 = x_390;
 } else {
- lean_dec_ref(x_381);
- x_396 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_395 = lean_box(0);
 }
-lean_inc(x_339);
-if (lean_is_scalar(x_396)) {
+x_396 = 0;
+if (lean_is_scalar(x_395)) {
  x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_397 = x_396;
+ x_397 = x_395;
 }
-lean_ctor_set(x_397, 0, x_325);
-lean_ctor_set(x_397, 1, x_326);
-lean_ctor_set(x_397, 2, x_327);
-lean_ctor_set(x_397, 3, x_339);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_398 = x_339;
-} else {
- lean_dec_ref(x_339);
- x_398 = lean_box(0);
-}
-lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_398)) {
- x_399 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_399 = x_398;
-}
-lean_ctor_set(x_399, 0, x_392);
-lean_ctor_set(x_399, 1, x_393);
-lean_ctor_set(x_399, 2, x_394);
-lean_ctor_set(x_399, 3, x_395);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_367);
-if (lean_is_scalar(x_391)) {
- x_400 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_400 = x_391;
-}
-lean_ctor_set(x_400, 0, x_397);
-lean_ctor_set(x_400, 1, x_389);
-lean_ctor_set(x_400, 2, x_390);
-lean_ctor_set(x_400, 3, x_399);
-lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_388);
-return x_400;
+lean_ctor_set(x_397, 0, x_392);
+lean_ctor_set(x_397, 1, x_393);
+lean_ctor_set(x_397, 2, x_394);
+lean_ctor_set(x_397, 3, x_392);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
+x_398 = 1;
+x_399 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_399, 0, x_375);
+lean_ctor_set(x_399, 1, x_376);
+lean_ctor_set(x_399, 2, x_377);
+lean_ctor_set(x_399, 3, x_397);
+lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_398);
+return x_399;
 }
 else
 {
-lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; uint8_t x_410; lean_object* x_411; lean_object* x_412; 
-x_401 = lean_ctor_get(x_338, 1);
+uint8_t x_400; 
+x_400 = lean_ctor_get_uint8(x_392, sizeof(void*)*4);
+if (x_400 == 0)
+{
+lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; lean_object* x_411; uint8_t x_412; lean_object* x_413; 
+x_401 = lean_ctor_get(x_390, 1);
 lean_inc(x_401);
-x_402 = lean_ctor_get(x_338, 2);
+x_402 = lean_ctor_get(x_390, 2);
 lean_inc(x_402);
-if (lean_is_exclusive(x_338)) {
- lean_ctor_release(x_338, 0);
- lean_ctor_release(x_338, 1);
- lean_ctor_release(x_338, 2);
- lean_ctor_release(x_338, 3);
- x_403 = x_338;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_403 = x_390;
 } else {
- lean_dec_ref(x_338);
+ lean_dec_ref(x_390);
  x_403 = lean_box(0);
 }
-x_404 = lean_ctor_get(x_339, 0);
+x_404 = lean_ctor_get(x_392, 0);
 lean_inc(x_404);
-x_405 = lean_ctor_get(x_339, 1);
+x_405 = lean_ctor_get(x_392, 1);
 lean_inc(x_405);
-x_406 = lean_ctor_get(x_339, 2);
+x_406 = lean_ctor_get(x_392, 2);
 lean_inc(x_406);
-x_407 = lean_ctor_get(x_339, 3);
+x_407 = lean_ctor_get(x_392, 3);
 lean_inc(x_407);
-if (lean_is_exclusive(x_339)) {
- lean_ctor_release(x_339, 0);
- lean_ctor_release(x_339, 1);
- lean_ctor_release(x_339, 2);
- lean_ctor_release(x_339, 3);
- x_408 = x_339;
+if (lean_is_exclusive(x_392)) {
+ lean_ctor_release(x_392, 0);
+ lean_ctor_release(x_392, 1);
+ lean_ctor_release(x_392, 2);
+ lean_ctor_release(x_392, 3);
+ x_408 = x_392;
 } else {
- lean_dec_ref(x_339);
+ lean_dec_ref(x_392);
  x_408 = lean_box(0);
 }
+x_409 = 1;
 if (lean_is_scalar(x_408)) {
- x_409 = lean_alloc_ctor(1, 4, 1);
+ x_410 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_409 = x_408;
+ x_410 = x_408;
 }
-lean_ctor_set(x_409, 0, x_404);
-lean_ctor_set(x_409, 1, x_405);
-lean_ctor_set(x_409, 2, x_406);
-lean_ctor_set(x_409, 3, x_407);
-lean_ctor_set_uint8(x_409, sizeof(void*)*4, x_388);
-x_410 = 0;
+lean_ctor_set(x_410, 0, x_375);
+lean_ctor_set(x_410, 1, x_376);
+lean_ctor_set(x_410, 2, x_377);
+lean_ctor_set(x_410, 3, x_391);
+lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
 if (lean_is_scalar(x_403)) {
  x_411 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_411 = x_403;
 }
-lean_ctor_set(x_411, 0, x_409);
-lean_ctor_set(x_411, 1, x_401);
-lean_ctor_set(x_411, 2, x_402);
-lean_ctor_set(x_411, 3, x_381);
-lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_410);
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_325);
-lean_ctor_set(x_412, 1, x_326);
-lean_ctor_set(x_412, 2, x_327);
-lean_ctor_set(x_412, 3, x_411);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_388);
-return x_412;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_411, 0, x_404);
+lean_ctor_set(x_411, 1, x_405);
+lean_ctor_set(x_411, 2, x_406);
+lean_ctor_set(x_411, 3, x_407);
+lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_409);
+x_412 = 0;
+x_413 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_413, 0, x_410);
+lean_ctor_set(x_413, 1, x_401);
+lean_ctor_set(x_413, 2, x_402);
+lean_ctor_set(x_413, 3, x_411);
+lean_ctor_set_uint8(x_413, sizeof(void*)*4, x_412);
+return x_413;
 }
 else
 {
-uint8_t x_413; 
-x_413 = l_Std_RBNode_isRed___rarg(x_325);
-if (x_413 == 0)
-{
-lean_object* x_414; lean_object* x_415; 
-x_414 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_325, x_2, x_3);
-x_415 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_415, 0, x_414);
-lean_ctor_set(x_415, 1, x_326);
-lean_ctor_set(x_415, 2, x_327);
-lean_ctor_set(x_415, 3, x_328);
-lean_ctor_set_uint8(x_415, sizeof(void*)*4, x_7);
-return x_415;
-}
-else
-{
-lean_object* x_416; lean_object* x_417; 
-x_416 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_325, x_2, x_3);
-x_417 = lean_ctor_get(x_416, 0);
-lean_inc(x_417);
-if (lean_obj_tag(x_417) == 0)
-{
-lean_object* x_418; 
-x_418 = lean_ctor_get(x_416, 3);
-lean_inc(x_418);
-if (lean_obj_tag(x_418) == 0)
-{
-lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; uint8_t x_424; lean_object* x_425; 
-x_419 = lean_ctor_get(x_416, 1);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_416, 2);
-lean_inc(x_420);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_421 = x_416;
+lean_object* x_414; lean_object* x_415; lean_object* x_416; uint8_t x_417; lean_object* x_418; uint8_t x_419; lean_object* x_420; 
+x_414 = lean_ctor_get(x_390, 1);
+lean_inc(x_414);
+x_415 = lean_ctor_get(x_390, 2);
+lean_inc(x_415);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_416 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_421 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_416 = lean_box(0);
 }
-x_422 = 0;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+x_417 = 0;
+if (lean_is_scalar(x_416)) {
+ x_418 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_418 = x_416;
+}
+lean_ctor_set(x_418, 0, x_391);
+lean_ctor_set(x_418, 1, x_414);
+lean_ctor_set(x_418, 2, x_415);
+lean_ctor_set(x_418, 3, x_392);
+lean_ctor_set_uint8(x_418, sizeof(void*)*4, x_417);
+x_419 = 1;
+x_420 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_420, 0, x_375);
+lean_ctor_set(x_420, 1, x_376);
+lean_ctor_set(x_420, 2, x_377);
+lean_ctor_set(x_420, 3, x_418);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_419);
+return x_420;
+}
 }
-lean_ctor_set(x_423, 0, x_418);
-lean_ctor_set(x_423, 1, x_419);
-lean_ctor_set(x_423, 2, x_420);
-lean_ctor_set(x_423, 3, x_418);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-x_424 = 1;
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_326);
-lean_ctor_set(x_425, 2, x_327);
-lean_ctor_set(x_425, 3, x_328);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_424);
-return x_425;
 }
 else
 {
-uint8_t x_426; 
-x_426 = lean_ctor_get_uint8(x_418, sizeof(void*)*4);
-if (x_426 == 0)
+uint8_t x_421; 
+x_421 = lean_ctor_get_uint8(x_391, sizeof(void*)*4);
+if (x_421 == 0)
 {
-lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; uint8_t x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; 
-x_427 = lean_ctor_get(x_416, 1);
+lean_object* x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; uint8_t x_431; lean_object* x_432; lean_object* x_433; uint8_t x_434; lean_object* x_435; 
+x_422 = lean_ctor_get(x_390, 1);
+lean_inc(x_422);
+x_423 = lean_ctor_get(x_390, 2);
+lean_inc(x_423);
+x_424 = lean_ctor_get(x_390, 3);
+lean_inc(x_424);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_425 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_425 = lean_box(0);
+}
+x_426 = lean_ctor_get(x_391, 0);
+lean_inc(x_426);
+x_427 = lean_ctor_get(x_391, 1);
 lean_inc(x_427);
-x_428 = lean_ctor_get(x_416, 2);
+x_428 = lean_ctor_get(x_391, 2);
 lean_inc(x_428);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_429 = x_416;
+x_429 = lean_ctor_get(x_391, 3);
+lean_inc(x_429);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_430 = x_391;
 } else {
- lean_dec_ref(x_416);
- x_429 = lean_box(0);
+ lean_dec_ref(x_391);
+ x_430 = lean_box(0);
 }
-x_430 = lean_ctor_get(x_418, 0);
-lean_inc(x_430);
-x_431 = lean_ctor_get(x_418, 1);
-lean_inc(x_431);
-x_432 = lean_ctor_get(x_418, 2);
-lean_inc(x_432);
-x_433 = lean_ctor_get(x_418, 3);
-lean_inc(x_433);
-if (lean_is_exclusive(x_418)) {
- lean_ctor_release(x_418, 0);
- lean_ctor_release(x_418, 1);
- lean_ctor_release(x_418, 2);
- lean_ctor_release(x_418, 3);
- x_434 = x_418;
+x_431 = 1;
+if (lean_is_scalar(x_430)) {
+ x_432 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_418);
- x_434 = lean_box(0);
+ x_432 = x_430;
 }
-x_435 = 1;
-if (lean_is_scalar(x_434)) {
- x_436 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_432, 0, x_375);
+lean_ctor_set(x_432, 1, x_376);
+lean_ctor_set(x_432, 2, x_377);
+lean_ctor_set(x_432, 3, x_426);
+lean_ctor_set_uint8(x_432, sizeof(void*)*4, x_431);
+if (lean_is_scalar(x_425)) {
+ x_433 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_436 = x_434;
+ x_433 = x_425;
 }
-lean_ctor_set(x_436, 0, x_417);
-lean_ctor_set(x_436, 1, x_427);
-lean_ctor_set(x_436, 2, x_428);
-lean_ctor_set(x_436, 3, x_430);
-lean_ctor_set_uint8(x_436, sizeof(void*)*4, x_435);
-if (lean_is_scalar(x_429)) {
- x_437 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_437 = x_429;
-}
-lean_ctor_set(x_437, 0, x_433);
-lean_ctor_set(x_437, 1, x_326);
-lean_ctor_set(x_437, 2, x_327);
-lean_ctor_set(x_437, 3, x_328);
-lean_ctor_set_uint8(x_437, sizeof(void*)*4, x_435);
-x_438 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_438, 0, x_436);
-lean_ctor_set(x_438, 1, x_431);
-lean_ctor_set(x_438, 2, x_432);
-lean_ctor_set(x_438, 3, x_437);
-lean_ctor_set_uint8(x_438, sizeof(void*)*4, x_426);
-return x_438;
+lean_ctor_set(x_433, 0, x_429);
+lean_ctor_set(x_433, 1, x_422);
+lean_ctor_set(x_433, 2, x_423);
+lean_ctor_set(x_433, 3, x_424);
+lean_ctor_set_uint8(x_433, sizeof(void*)*4, x_431);
+x_434 = 0;
+x_435 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_435, 0, x_432);
+lean_ctor_set(x_435, 1, x_427);
+lean_ctor_set(x_435, 2, x_428);
+lean_ctor_set(x_435, 3, x_433);
+lean_ctor_set_uint8(x_435, sizeof(void*)*4, x_434);
+return x_435;
 }
 else
 {
-lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; 
-x_439 = lean_ctor_get(x_416, 1);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_416, 2);
-lean_inc(x_440);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_441 = x_416;
+lean_object* x_436; 
+x_436 = lean_ctor_get(x_390, 3);
+lean_inc(x_436);
+if (lean_obj_tag(x_436) == 0)
+{
+lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; 
+x_437 = lean_ctor_get(x_390, 1);
+lean_inc(x_437);
+x_438 = lean_ctor_get(x_390, 2);
+lean_inc(x_438);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_439 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_441 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_439 = lean_box(0);
 }
-x_442 = 0;
-if (lean_is_scalar(x_441)) {
- x_443 = lean_alloc_ctor(1, 4, 1);
+x_440 = 0;
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_441 = x_439;
 }
-lean_ctor_set(x_443, 0, x_417);
-lean_ctor_set(x_443, 1, x_439);
-lean_ctor_set(x_443, 2, x_440);
-lean_ctor_set(x_443, 3, x_418);
+lean_ctor_set(x_441, 0, x_391);
+lean_ctor_set(x_441, 1, x_437);
+lean_ctor_set(x_441, 2, x_438);
+lean_ctor_set(x_441, 3, x_436);
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+x_442 = 1;
+x_443 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_375);
+lean_ctor_set(x_443, 1, x_376);
+lean_ctor_set(x_443, 2, x_377);
+lean_ctor_set(x_443, 3, x_441);
 lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-x_444 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_444, 0, x_443);
-lean_ctor_set(x_444, 1, x_326);
-lean_ctor_set(x_444, 2, x_327);
-lean_ctor_set(x_444, 3, x_328);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_426);
-return x_444;
-}
-}
+return x_443;
 }
 else
 {
-uint8_t x_445; 
-x_445 = lean_ctor_get_uint8(x_417, sizeof(void*)*4);
-if (x_445 == 0)
+uint8_t x_444; 
+x_444 = lean_ctor_get_uint8(x_436, sizeof(void*)*4);
+if (x_444 == 0)
 {
-lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; 
-x_446 = lean_ctor_get(x_416, 1);
+lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; uint8_t x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_445 = lean_ctor_get(x_390, 1);
+lean_inc(x_445);
+x_446 = lean_ctor_get(x_390, 2);
 lean_inc(x_446);
-x_447 = lean_ctor_get(x_416, 2);
-lean_inc(x_447);
-x_448 = lean_ctor_get(x_416, 3);
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_447 = x_390;
+} else {
+ lean_dec_ref(x_390);
+ x_447 = lean_box(0);
+}
+x_448 = lean_ctor_get(x_436, 0);
 lean_inc(x_448);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_449 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_449 = lean_box(0);
-}
-x_450 = lean_ctor_get(x_417, 0);
+x_449 = lean_ctor_get(x_436, 1);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_436, 2);
 lean_inc(x_450);
-x_451 = lean_ctor_get(x_417, 1);
+x_451 = lean_ctor_get(x_436, 3);
 lean_inc(x_451);
-x_452 = lean_ctor_get(x_417, 2);
-lean_inc(x_452);
-x_453 = lean_ctor_get(x_417, 3);
-lean_inc(x_453);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_454 = x_417;
+if (lean_is_exclusive(x_436)) {
+ lean_ctor_release(x_436, 0);
+ lean_ctor_release(x_436, 1);
+ lean_ctor_release(x_436, 2);
+ lean_ctor_release(x_436, 3);
+ x_452 = x_436;
 } else {
- lean_dec_ref(x_417);
- x_454 = lean_box(0);
+ lean_dec_ref(x_436);
+ x_452 = lean_box(0);
 }
-x_455 = 1;
-if (lean_is_scalar(x_454)) {
+x_453 = 1;
+lean_inc(x_391);
+if (lean_is_scalar(x_452)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_452;
+}
+lean_ctor_set(x_454, 0, x_375);
+lean_ctor_set(x_454, 1, x_376);
+lean_ctor_set(x_454, 2, x_377);
+lean_ctor_set(x_454, 3, x_391);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_455 = x_391;
+} else {
+ lean_dec_ref(x_391);
+ x_455 = lean_box(0);
+}
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_453);
+if (lean_is_scalar(x_455)) {
  x_456 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_456 = x_454;
+ x_456 = x_455;
 }
-lean_ctor_set(x_456, 0, x_450);
-lean_ctor_set(x_456, 1, x_451);
-lean_ctor_set(x_456, 2, x_452);
-lean_ctor_set(x_456, 3, x_453);
-lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
-if (lean_is_scalar(x_449)) {
- x_457 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_456, 0, x_448);
+lean_ctor_set(x_456, 1, x_449);
+lean_ctor_set(x_456, 2, x_450);
+lean_ctor_set(x_456, 3, x_451);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_453);
+x_457 = 0;
+if (lean_is_scalar(x_447)) {
+ x_458 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_457 = x_449;
+ x_458 = x_447;
 }
-lean_ctor_set(x_457, 0, x_448);
-lean_ctor_set(x_457, 1, x_326);
-lean_ctor_set(x_457, 2, x_327);
-lean_ctor_set(x_457, 3, x_328);
-lean_ctor_set_uint8(x_457, sizeof(void*)*4, x_455);
-x_458 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_458, 0, x_456);
-lean_ctor_set(x_458, 1, x_446);
-lean_ctor_set(x_458, 2, x_447);
-lean_ctor_set(x_458, 3, x_457);
-lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_445);
+lean_ctor_set(x_458, 0, x_454);
+lean_ctor_set(x_458, 1, x_445);
+lean_ctor_set(x_458, 2, x_446);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
 return x_458;
 }
 else
 {
-lean_object* x_459; 
-x_459 = lean_ctor_get(x_416, 3);
+lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; uint8_t x_468; lean_object* x_469; uint8_t x_470; lean_object* x_471; 
+x_459 = lean_ctor_get(x_390, 1);
 lean_inc(x_459);
-if (lean_obj_tag(x_459) == 0)
-{
-lean_object* x_460; lean_object* x_461; lean_object* x_462; uint8_t x_463; lean_object* x_464; lean_object* x_465; 
-x_460 = lean_ctor_get(x_416, 1);
+x_460 = lean_ctor_get(x_390, 2);
 lean_inc(x_460);
-x_461 = lean_ctor_get(x_416, 2);
-lean_inc(x_461);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_462 = x_416;
+if (lean_is_exclusive(x_390)) {
+ lean_ctor_release(x_390, 0);
+ lean_ctor_release(x_390, 1);
+ lean_ctor_release(x_390, 2);
+ lean_ctor_release(x_390, 3);
+ x_461 = x_390;
 } else {
- lean_dec_ref(x_416);
- x_462 = lean_box(0);
+ lean_dec_ref(x_390);
+ x_461 = lean_box(0);
 }
-x_463 = 0;
-if (lean_is_scalar(x_462)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
+x_462 = lean_ctor_get(x_391, 0);
+lean_inc(x_462);
+x_463 = lean_ctor_get(x_391, 1);
+lean_inc(x_463);
+x_464 = lean_ctor_get(x_391, 2);
+lean_inc(x_464);
+x_465 = lean_ctor_get(x_391, 3);
+lean_inc(x_465);
+if (lean_is_exclusive(x_391)) {
+ lean_ctor_release(x_391, 0);
+ lean_ctor_release(x_391, 1);
+ lean_ctor_release(x_391, 2);
+ lean_ctor_release(x_391, 3);
+ x_466 = x_391;
 } else {
- x_464 = x_462;
+ lean_dec_ref(x_391);
+ x_466 = lean_box(0);
+}
+if (lean_is_scalar(x_466)) {
+ x_467 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_467 = x_466;
+}
+lean_ctor_set(x_467, 0, x_462);
+lean_ctor_set(x_467, 1, x_463);
+lean_ctor_set(x_467, 2, x_464);
+lean_ctor_set(x_467, 3, x_465);
+lean_ctor_set_uint8(x_467, sizeof(void*)*4, x_444);
+x_468 = 0;
+if (lean_is_scalar(x_461)) {
+ x_469 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_469 = x_461;
+}
+lean_ctor_set(x_469, 0, x_467);
+lean_ctor_set(x_469, 1, x_459);
+lean_ctor_set(x_469, 2, x_460);
+lean_ctor_set(x_469, 3, x_436);
+lean_ctor_set_uint8(x_469, sizeof(void*)*4, x_468);
+x_470 = 1;
+x_471 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_471, 0, x_375);
+lean_ctor_set(x_471, 1, x_376);
+lean_ctor_set(x_471, 2, x_377);
+lean_ctor_set(x_471, 3, x_469);
+lean_ctor_set_uint8(x_471, sizeof(void*)*4, x_470);
+return x_471;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_464, 0, x_417);
-lean_ctor_set(x_464, 1, x_460);
-lean_ctor_set(x_464, 2, x_461);
-lean_ctor_set(x_464, 3, x_459);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_463);
-x_465 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_465, 0, x_464);
-lean_ctor_set(x_465, 1, x_326);
-lean_ctor_set(x_465, 2, x_327);
-lean_ctor_set(x_465, 3, x_328);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_445);
-return x_465;
 }
 else
 {
-uint8_t x_466; 
-x_466 = lean_ctor_get_uint8(x_459, sizeof(void*)*4);
-if (x_466 == 0)
+uint8_t x_472; 
+x_472 = l_Std_RBNode_isRed___rarg(x_375);
+if (x_472 == 0)
 {
-lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; 
-x_467 = lean_ctor_get(x_416, 1);
-lean_inc(x_467);
-x_468 = lean_ctor_get(x_416, 2);
-lean_inc(x_468);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_469 = x_416;
-} else {
- lean_dec_ref(x_416);
- x_469 = lean_box(0);
-}
-x_470 = lean_ctor_get(x_459, 0);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_459, 1);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_459, 2);
-lean_inc(x_472);
-x_473 = lean_ctor_get(x_459, 3);
-lean_inc(x_473);
-if (lean_is_exclusive(x_459)) {
- lean_ctor_release(x_459, 0);
- lean_ctor_release(x_459, 1);
- lean_ctor_release(x_459, 2);
- lean_ctor_release(x_459, 3);
- x_474 = x_459;
-} else {
- lean_dec_ref(x_459);
- x_474 = lean_box(0);
-}
-lean_inc(x_417);
-if (lean_is_scalar(x_474)) {
- x_475 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_475 = x_474;
-}
-lean_ctor_set(x_475, 0, x_417);
-lean_ctor_set(x_475, 1, x_467);
-lean_ctor_set(x_475, 2, x_468);
-lean_ctor_set(x_475, 3, x_470);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_476 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_476 = lean_box(0);
-}
-lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_476)) {
- x_477 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_477 = x_476;
-}
-lean_ctor_set(x_477, 0, x_473);
-lean_ctor_set(x_477, 1, x_326);
-lean_ctor_set(x_477, 2, x_327);
-lean_ctor_set(x_477, 3, x_328);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_445);
-if (lean_is_scalar(x_469)) {
- x_478 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_478 = x_469;
-}
-lean_ctor_set(x_478, 0, x_475);
-lean_ctor_set(x_478, 1, x_471);
-lean_ctor_set(x_478, 2, x_472);
-lean_ctor_set(x_478, 3, x_477);
-lean_ctor_set_uint8(x_478, sizeof(void*)*4, x_466);
-return x_478;
+lean_object* x_473; uint8_t x_474; lean_object* x_475; 
+x_473 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_375, x_2, x_3);
+x_474 = 1;
+x_475 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_475, 0, x_473);
+lean_ctor_set(x_475, 1, x_376);
+lean_ctor_set(x_475, 2, x_377);
+lean_ctor_set(x_475, 3, x_378);
+lean_ctor_set_uint8(x_475, sizeof(void*)*4, x_474);
+return x_475;
 }
 else
 {
-lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; uint8_t x_488; lean_object* x_489; lean_object* x_490; 
-x_479 = lean_ctor_get(x_416, 1);
+lean_object* x_476; lean_object* x_477; 
+x_476 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_375, x_2, x_3);
+x_477 = lean_ctor_get(x_476, 0);
+lean_inc(x_477);
+if (lean_obj_tag(x_477) == 0)
+{
+lean_object* x_478; 
+x_478 = lean_ctor_get(x_476, 3);
+lean_inc(x_478);
+if (lean_obj_tag(x_478) == 0)
+{
+lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; uint8_t x_484; lean_object* x_485; 
+x_479 = lean_ctor_get(x_476, 1);
 lean_inc(x_479);
-x_480 = lean_ctor_get(x_416, 2);
+x_480 = lean_ctor_get(x_476, 2);
 lean_inc(x_480);
-if (lean_is_exclusive(x_416)) {
- lean_ctor_release(x_416, 0);
- lean_ctor_release(x_416, 1);
- lean_ctor_release(x_416, 2);
- lean_ctor_release(x_416, 3);
- x_481 = x_416;
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_481 = x_476;
 } else {
- lean_dec_ref(x_416);
+ lean_dec_ref(x_476);
  x_481 = lean_box(0);
 }
-x_482 = lean_ctor_get(x_417, 0);
-lean_inc(x_482);
-x_483 = lean_ctor_get(x_417, 1);
-lean_inc(x_483);
-x_484 = lean_ctor_get(x_417, 2);
-lean_inc(x_484);
-x_485 = lean_ctor_get(x_417, 3);
-lean_inc(x_485);
-if (lean_is_exclusive(x_417)) {
- lean_ctor_release(x_417, 0);
- lean_ctor_release(x_417, 1);
- lean_ctor_release(x_417, 2);
- lean_ctor_release(x_417, 3);
- x_486 = x_417;
-} else {
- lean_dec_ref(x_417);
- x_486 = lean_box(0);
-}
-if (lean_is_scalar(x_486)) {
- x_487 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_487 = x_486;
-}
-lean_ctor_set(x_487, 0, x_482);
-lean_ctor_set(x_487, 1, x_483);
-lean_ctor_set(x_487, 2, x_484);
-lean_ctor_set(x_487, 3, x_485);
-lean_ctor_set_uint8(x_487, sizeof(void*)*4, x_466);
-x_488 = 0;
+x_482 = 0;
 if (lean_is_scalar(x_481)) {
- x_489 = lean_alloc_ctor(1, 4, 1);
+ x_483 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_489 = x_481;
+ x_483 = x_481;
 }
-lean_ctor_set(x_489, 0, x_487);
-lean_ctor_set(x_489, 1, x_479);
-lean_ctor_set(x_489, 2, x_480);
-lean_ctor_set(x_489, 3, x_459);
-lean_ctor_set_uint8(x_489, sizeof(void*)*4, x_488);
-x_490 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_490, 0, x_489);
-lean_ctor_set(x_490, 1, x_326);
-lean_ctor_set(x_490, 2, x_327);
-lean_ctor_set(x_490, 3, x_328);
-lean_ctor_set_uint8(x_490, sizeof(void*)*4, x_466);
-return x_490;
+lean_ctor_set(x_483, 0, x_478);
+lean_ctor_set(x_483, 1, x_479);
+lean_ctor_set(x_483, 2, x_480);
+lean_ctor_set(x_483, 3, x_478);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+x_484 = 1;
+x_485 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_485, 0, x_483);
+lean_ctor_set(x_485, 1, x_376);
+lean_ctor_set(x_485, 2, x_377);
+lean_ctor_set(x_485, 3, x_378);
+lean_ctor_set_uint8(x_485, sizeof(void*)*4, x_484);
+return x_485;
+}
+else
+{
+uint8_t x_486; 
+x_486 = lean_ctor_get_uint8(x_478, sizeof(void*)*4);
+if (x_486 == 0)
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; uint8_t x_495; lean_object* x_496; lean_object* x_497; uint8_t x_498; lean_object* x_499; 
+x_487 = lean_ctor_get(x_476, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_476, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_489 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_489 = lean_box(0);
+}
+x_490 = lean_ctor_get(x_478, 0);
+lean_inc(x_490);
+x_491 = lean_ctor_get(x_478, 1);
+lean_inc(x_491);
+x_492 = lean_ctor_get(x_478, 2);
+lean_inc(x_492);
+x_493 = lean_ctor_get(x_478, 3);
+lean_inc(x_493);
+if (lean_is_exclusive(x_478)) {
+ lean_ctor_release(x_478, 0);
+ lean_ctor_release(x_478, 1);
+ lean_ctor_release(x_478, 2);
+ lean_ctor_release(x_478, 3);
+ x_494 = x_478;
+} else {
+ lean_dec_ref(x_478);
+ x_494 = lean_box(0);
+}
+x_495 = 1;
+if (lean_is_scalar(x_494)) {
+ x_496 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_496 = x_494;
+}
+lean_ctor_set(x_496, 0, x_477);
+lean_ctor_set(x_496, 1, x_487);
+lean_ctor_set(x_496, 2, x_488);
+lean_ctor_set(x_496, 3, x_490);
+lean_ctor_set_uint8(x_496, sizeof(void*)*4, x_495);
+if (lean_is_scalar(x_489)) {
+ x_497 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_497 = x_489;
+}
+lean_ctor_set(x_497, 0, x_493);
+lean_ctor_set(x_497, 1, x_376);
+lean_ctor_set(x_497, 2, x_377);
+lean_ctor_set(x_497, 3, x_378);
+lean_ctor_set_uint8(x_497, sizeof(void*)*4, x_495);
+x_498 = 0;
+x_499 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_499, 0, x_496);
+lean_ctor_set(x_499, 1, x_491);
+lean_ctor_set(x_499, 2, x_492);
+lean_ctor_set(x_499, 3, x_497);
+lean_ctor_set_uint8(x_499, sizeof(void*)*4, x_498);
+return x_499;
+}
+else
+{
+lean_object* x_500; lean_object* x_501; lean_object* x_502; uint8_t x_503; lean_object* x_504; uint8_t x_505; lean_object* x_506; 
+x_500 = lean_ctor_get(x_476, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_476, 2);
+lean_inc(x_501);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_502 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_502 = lean_box(0);
+}
+x_503 = 0;
+if (lean_is_scalar(x_502)) {
+ x_504 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_504 = x_502;
+}
+lean_ctor_set(x_504, 0, x_477);
+lean_ctor_set(x_504, 1, x_500);
+lean_ctor_set(x_504, 2, x_501);
+lean_ctor_set(x_504, 3, x_478);
+lean_ctor_set_uint8(x_504, sizeof(void*)*4, x_503);
+x_505 = 1;
+x_506 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_506, 0, x_504);
+lean_ctor_set(x_506, 1, x_376);
+lean_ctor_set(x_506, 2, x_377);
+lean_ctor_set(x_506, 3, x_378);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_505);
+return x_506;
+}
+}
+}
+else
+{
+uint8_t x_507; 
+x_507 = lean_ctor_get_uint8(x_477, sizeof(void*)*4);
+if (x_507 == 0)
+{
+lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; lean_object* x_516; uint8_t x_517; lean_object* x_518; lean_object* x_519; uint8_t x_520; lean_object* x_521; 
+x_508 = lean_ctor_get(x_476, 1);
+lean_inc(x_508);
+x_509 = lean_ctor_get(x_476, 2);
+lean_inc(x_509);
+x_510 = lean_ctor_get(x_476, 3);
+lean_inc(x_510);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_511 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_511 = lean_box(0);
+}
+x_512 = lean_ctor_get(x_477, 0);
+lean_inc(x_512);
+x_513 = lean_ctor_get(x_477, 1);
+lean_inc(x_513);
+x_514 = lean_ctor_get(x_477, 2);
+lean_inc(x_514);
+x_515 = lean_ctor_get(x_477, 3);
+lean_inc(x_515);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_516 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_516 = lean_box(0);
+}
+x_517 = 1;
+if (lean_is_scalar(x_516)) {
+ x_518 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_518 = x_516;
+}
+lean_ctor_set(x_518, 0, x_512);
+lean_ctor_set(x_518, 1, x_513);
+lean_ctor_set(x_518, 2, x_514);
+lean_ctor_set(x_518, 3, x_515);
+lean_ctor_set_uint8(x_518, sizeof(void*)*4, x_517);
+if (lean_is_scalar(x_511)) {
+ x_519 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_519 = x_511;
+}
+lean_ctor_set(x_519, 0, x_510);
+lean_ctor_set(x_519, 1, x_376);
+lean_ctor_set(x_519, 2, x_377);
+lean_ctor_set(x_519, 3, x_378);
+lean_ctor_set_uint8(x_519, sizeof(void*)*4, x_517);
+x_520 = 0;
+x_521 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_521, 0, x_518);
+lean_ctor_set(x_521, 1, x_508);
+lean_ctor_set(x_521, 2, x_509);
+lean_ctor_set(x_521, 3, x_519);
+lean_ctor_set_uint8(x_521, sizeof(void*)*4, x_520);
+return x_521;
+}
+else
+{
+lean_object* x_522; 
+x_522 = lean_ctor_get(x_476, 3);
+lean_inc(x_522);
+if (lean_obj_tag(x_522) == 0)
+{
+lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; uint8_t x_528; lean_object* x_529; 
+x_523 = lean_ctor_get(x_476, 1);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_476, 2);
+lean_inc(x_524);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_525 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_525 = lean_box(0);
+}
+x_526 = 0;
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_477);
+lean_ctor_set(x_527, 1, x_523);
+lean_ctor_set(x_527, 2, x_524);
+lean_ctor_set(x_527, 3, x_522);
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+x_528 = 1;
+x_529 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_529, 0, x_527);
+lean_ctor_set(x_529, 1, x_376);
+lean_ctor_set(x_529, 2, x_377);
+lean_ctor_set(x_529, 3, x_378);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_528);
+return x_529;
+}
+else
+{
+uint8_t x_530; 
+x_530 = lean_ctor_get_uint8(x_522, sizeof(void*)*4);
+if (x_530 == 0)
+{
+lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; uint8_t x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_531 = lean_ctor_get(x_476, 1);
+lean_inc(x_531);
+x_532 = lean_ctor_get(x_476, 2);
+lean_inc(x_532);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_533 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_533 = lean_box(0);
+}
+x_534 = lean_ctor_get(x_522, 0);
+lean_inc(x_534);
+x_535 = lean_ctor_get(x_522, 1);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_522, 2);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_522, 3);
+lean_inc(x_537);
+if (lean_is_exclusive(x_522)) {
+ lean_ctor_release(x_522, 0);
+ lean_ctor_release(x_522, 1);
+ lean_ctor_release(x_522, 2);
+ lean_ctor_release(x_522, 3);
+ x_538 = x_522;
+} else {
+ lean_dec_ref(x_522);
+ x_538 = lean_box(0);
+}
+x_539 = 1;
+lean_inc(x_477);
+if (lean_is_scalar(x_538)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_538;
+}
+lean_ctor_set(x_540, 0, x_477);
+lean_ctor_set(x_540, 1, x_531);
+lean_ctor_set(x_540, 2, x_532);
+lean_ctor_set(x_540, 3, x_534);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_541 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_541 = lean_box(0);
+}
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_539);
+if (lean_is_scalar(x_541)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_541;
+}
+lean_ctor_set(x_542, 0, x_537);
+lean_ctor_set(x_542, 1, x_376);
+lean_ctor_set(x_542, 2, x_377);
+lean_ctor_set(x_542, 3, x_378);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_539);
+x_543 = 0;
+if (lean_is_scalar(x_533)) {
+ x_544 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_544 = x_533;
+}
+lean_ctor_set(x_544, 0, x_540);
+lean_ctor_set(x_544, 1, x_535);
+lean_ctor_set(x_544, 2, x_536);
+lean_ctor_set(x_544, 3, x_542);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
+}
+else
+{
+lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; uint8_t x_554; lean_object* x_555; uint8_t x_556; lean_object* x_557; 
+x_545 = lean_ctor_get(x_476, 1);
+lean_inc(x_545);
+x_546 = lean_ctor_get(x_476, 2);
+lean_inc(x_546);
+if (lean_is_exclusive(x_476)) {
+ lean_ctor_release(x_476, 0);
+ lean_ctor_release(x_476, 1);
+ lean_ctor_release(x_476, 2);
+ lean_ctor_release(x_476, 3);
+ x_547 = x_476;
+} else {
+ lean_dec_ref(x_476);
+ x_547 = lean_box(0);
+}
+x_548 = lean_ctor_get(x_477, 0);
+lean_inc(x_548);
+x_549 = lean_ctor_get(x_477, 1);
+lean_inc(x_549);
+x_550 = lean_ctor_get(x_477, 2);
+lean_inc(x_550);
+x_551 = lean_ctor_get(x_477, 3);
+lean_inc(x_551);
+if (lean_is_exclusive(x_477)) {
+ lean_ctor_release(x_477, 0);
+ lean_ctor_release(x_477, 1);
+ lean_ctor_release(x_477, 2);
+ lean_ctor_release(x_477, 3);
+ x_552 = x_477;
+} else {
+ lean_dec_ref(x_477);
+ x_552 = lean_box(0);
+}
+if (lean_is_scalar(x_552)) {
+ x_553 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_553 = x_552;
+}
+lean_ctor_set(x_553, 0, x_548);
+lean_ctor_set(x_553, 1, x_549);
+lean_ctor_set(x_553, 2, x_550);
+lean_ctor_set(x_553, 3, x_551);
+lean_ctor_set_uint8(x_553, sizeof(void*)*4, x_530);
+x_554 = 0;
+if (lean_is_scalar(x_547)) {
+ x_555 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_555 = x_547;
+}
+lean_ctor_set(x_555, 0, x_553);
+lean_ctor_set(x_555, 1, x_545);
+lean_ctor_set(x_555, 2, x_546);
+lean_ctor_set(x_555, 3, x_522);
+lean_ctor_set_uint8(x_555, sizeof(void*)*4, x_554);
+x_556 = 1;
+x_557 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_557, 0, x_555);
+lean_ctor_set(x_557, 1, x_376);
+lean_ctor_set(x_557, 2, x_377);
+lean_ctor_set(x_557, 3, x_378);
+lean_ctor_set_uint8(x_557, sizeof(void*)*4, x_556);
+return x_557;
 }
 }
 }
@@ -9940,15 +10359,15 @@ return x_490;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg(lean_object* x_1, uint32_t x_2, lean_object* x_3) {
 _start:
 {
 uint8_t x_4; 
@@ -9956,27 +10375,27 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
 }
 }
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5(lean_object* x_1) {
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Data_Trie_2__insertAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_Trie_insert_loop___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -9993,13 +10412,13 @@ uint32_t x_9; lean_object* x_10; lean_object* x_11;
 x_9 = lean_string_utf8_get(x_1, x_4);
 x_10 = lean_string_utf8_next(x_1, x_4);
 lean_inc(x_7);
-x_11 = l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg(x_7, x_9);
+x_11 = l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg(x_7, x_9);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_object* x_12; lean_object* x_13; 
-x_12 = l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg(x_1, x_2, x_10);
+x_12 = l_Lean_Parser_Trie_insert_insertEmpty___rarg(x_1, x_2, x_10);
 lean_dec(x_10);
-x_13 = l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg(x_7, x_9, x_12);
+x_13 = l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg(x_7, x_9, x_12);
 lean_ctor_set(x_3, 1, x_13);
 return x_3;
 }
@@ -10009,9 +10428,9 @@ lean_object* x_14; lean_object* x_15; lean_object* x_16;
 x_14 = lean_ctor_get(x_11, 0);
 lean_inc(x_14);
 lean_dec(x_11);
-x_15 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_1, x_2, x_14, x_10);
+x_15 = l_Lean_Parser_Trie_insert_loop___rarg(x_1, x_2, x_14, x_10);
 lean_dec(x_10);
-x_16 = l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg(x_7, x_9, x_15);
+x_16 = l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg(x_7, x_9, x_15);
 lean_ctor_set(x_3, 1, x_16);
 return x_3;
 }
@@ -10041,13 +10460,13 @@ uint32_t x_21; lean_object* x_22; lean_object* x_23;
 x_21 = lean_string_utf8_get(x_1, x_4);
 x_22 = lean_string_utf8_next(x_1, x_4);
 lean_inc(x_19);
-x_23 = l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg(x_19, x_21);
+x_23 = l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg(x_19, x_21);
 if (lean_obj_tag(x_23) == 0)
 {
 lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_24 = l___private_Lean_Data_Trie_1__insertEmptyAux___main___rarg(x_1, x_2, x_22);
+x_24 = l_Lean_Parser_Trie_insert_insertEmpty___rarg(x_1, x_2, x_22);
 lean_dec(x_22);
-x_25 = l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg(x_19, x_21, x_24);
+x_25 = l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg(x_19, x_21, x_24);
 x_26 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_26, 0, x_18);
 lean_ctor_set(x_26, 1, x_25);
@@ -10059,9 +10478,9 @@ lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30;
 x_27 = lean_ctor_get(x_23, 0);
 lean_inc(x_27);
 lean_dec(x_23);
-x_28 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_1, x_2, x_27, x_22);
+x_28 = l_Lean_Parser_Trie_insert_loop___rarg(x_1, x_2, x_27, x_22);
 lean_dec(x_22);
-x_29 = l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg(x_19, x_21, x_28);
+x_29 = l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg(x_19, x_21, x_28);
 x_30 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_30, 0, x_18);
 lean_ctor_set(x_30, 1, x_29);
@@ -10082,115 +10501,89 @@ return x_32;
 }
 }
 }
-lean_object* l___private_Lean_Data_Trie_2__insertAux___main(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_insert_loop(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_2__insertAux___main___rarg___boxed), 4, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_insert_loop___rarg___boxed), 4, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint32_t x_3; lean_object* x_4; 
 x_3 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_4 = l_Std_RBNode_find___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__1___rarg(x_1, x_3);
+x_4 = l_Std_RBNode_find___at_Lean_Parser_Trie_insert_loop___spec__1___rarg(x_1, x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint32_t x_4; lean_object* x_5; 
 x_4 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_5 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__3___rarg(x_1, x_4, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__3___rarg(x_1, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint32_t x_4; lean_object* x_5; 
 x_4 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_5 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__4___rarg(x_1, x_4, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__4___rarg(x_1, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint32_t x_4; lean_object* x_5; 
 x_4 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_5 = l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__2___rarg(x_1, x_4, x_3);
+x_5 = l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__2___rarg(x_1, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint32_t x_4; lean_object* x_5; 
 x_4 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_5 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__6___rarg(x_1, x_4, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__6___rarg(x_1, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint32_t x_4; lean_object* x_5; 
 x_4 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_5 = l_Std_RBNode_ins___main___at___private_Lean_Data_Trie_2__insertAux___main___spec__7___rarg(x_1, x_4, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_Trie_insert_loop___spec__7___rarg(x_1, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint32_t x_4; lean_object* x_5; 
 x_4 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_5 = l_Std_RBNode_insert___at___private_Lean_Data_Trie_2__insertAux___main___spec__5___rarg(x_1, x_4, x_3);
+x_5 = l_Std_RBNode_insert___at_Lean_Parser_Trie_insert_loop___spec__5___rarg(x_1, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l___private_Lean_Data_Trie_2__insertAux___main___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_Trie_insert_loop___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_1, x_2, x_3, x_4);
-lean_dec(x_4);
-lean_dec(x_1);
-return x_5;
-}
-}
-lean_object* l___private_Lean_Data_Trie_2__insertAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
-lean_object* l___private_Lean_Data_Trie_2__insertAux(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_2__insertAux___rarg___boxed), 4, 0);
-return x_2;
-}
-}
-lean_object* l___private_Lean_Data_Trie_2__insertAux___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l___private_Lean_Data_Trie_2__insertAux___rarg(x_1, x_2, x_3, x_4);
+x_5 = l_Lean_Parser_Trie_insert_loop___rarg(x_1, x_2, x_3, x_4);
 lean_dec(x_4);
 lean_dec(x_1);
 return x_5;
@@ -10201,7 +10594,7 @@ _start:
 {
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_unsigned_to_nat(0u);
-x_5 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_2, x_3, x_1, x_4);
+x_5 = l_Lean_Parser_Trie_insert_loop___rarg(x_2, x_3, x_1, x_4);
 return x_5;
 }
 }
@@ -10222,7 +10615,98 @@ lean_dec(x_2);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1___rarg(lean_object* x_1, uint32_t x_2) {
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_find_x3f_loop_match__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__2___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (x_1 == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_find_x3f_loop_match__2___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__2___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 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_Lean_Parser_Trie_find_x3f_loop_match__2___rarg(x_4, x_2, x_3);
+return x_5;
+}
+}
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_3(x_3, x_4, x_5, x_2);
+return x_6;
+}
+}
+lean_object* l_Lean_Parser_Trie_find_x3f_loop_match__3(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_find_x3f_loop_match__3___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1___rarg(lean_object* x_1, uint32_t x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -10278,15 +10762,15 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Trie_find_x3f_loop___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; lean_object* x_5; uint8_t x_6; 
@@ -10303,7 +10787,7 @@ lean_dec(x_4);
 x_7 = lean_string_utf8_get(x_1, x_3);
 x_8 = lean_string_utf8_next(x_1, x_3);
 lean_dec(x_3);
-x_9 = l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1___rarg(x_5, x_7);
+x_9 = l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1___rarg(x_5, x_7);
 if (lean_obj_tag(x_9) == 0)
 {
 lean_object* x_10; 
@@ -10330,54 +10814,29 @@ return x_4;
 }
 }
 }
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_find_x3f_loop(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_find_x3f_loop___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint32_t x_3; lean_object* x_4; 
 x_3 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_4 = l_Std_RBNode_find___main___at___private_Lean_Data_Trie_3__findAux_x3f___main___spec__1___rarg(x_1, x_3);
+x_4 = l_Std_RBNode_find___at_Lean_Parser_Trie_find_x3f_loop___spec__1___rarg(x_1, x_3);
 return x_4;
 }
 }
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Parser_Trie_find_x3f_loop___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(x_1, x_2, x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(x_1, x_2, x_3);
-return x_4;
-}
-}
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_3__findAux_x3f___rarg___boxed), 3, 0);
-return x_2;
-}
-}
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l___private_Lean_Data_Trie_3__findAux_x3f___rarg(x_1, x_2, x_3);
+x_4 = l_Lean_Parser_Trie_find_x3f_loop___rarg(x_1, x_2, x_3);
 lean_dec(x_1);
 return x_4;
 }
@@ -10387,7 +10846,7 @@ _start:
 {
 lean_object* x_3; lean_object* x_4; 
 x_3 = lean_unsigned_to_nat(0u);
-x_4 = l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(x_2, x_1, x_3);
+x_4 = l_Lean_Parser_Trie_find_x3f_loop___rarg(x_2, x_1, x_3);
 return x_4;
 }
 }
@@ -10408,7 +10867,42 @@ lean_dec(x_2);
 return x_3;
 }
 }
-lean_object* l___private_Lean_Data_Trie_4__updtAcc___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_3);
+x_5 = lean_apply_1(x_4, x_2);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_4);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_ctor_get(x_2, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_2, 1);
+lean_inc(x_8);
+lean_dec(x_2);
+x_9 = lean_apply_3(x_3, x_6, x_7, x_8);
+return x_9;
+}
+}
+}
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc_match__1___rarg), 4, 0);
+return x_3;
+}
+}
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -10419,32 +10913,141 @@ return x_3;
 }
 else
 {
-lean_object* x_4; 
-x_4 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_4, 0, x_2);
-lean_ctor_set(x_4, 1, x_1);
-return x_4;
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_1);
+if (x_4 == 0)
+{
+lean_object* x_5; 
+x_5 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_5, 0, x_2);
+lean_ctor_set(x_5, 1, x_1);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_7, 0, x_6);
+x_8 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_8, 0, x_2);
+lean_ctor_set(x_8, 1, x_7);
+return x_8;
 }
 }
 }
-lean_object* l___private_Lean_Data_Trie_4__updtAcc(lean_object* x_1) {
+}
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_4__updtAcc___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Data_Trie_4__updtAcc___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l___private_Lean_Data_Trie_4__updtAcc___rarg(x_1, x_2, x_3);
+x_4 = l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg(x_1, x_2, x_3);
 lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1___rarg(lean_object* x_1, uint32_t x_2) {
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_matchPrefix_loop_match__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__2___rarg(uint8_t x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (x_1 == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_matchPrefix_loop_match__2___rarg___boxed), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__2___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 = lean_unbox(x_1);
+lean_dec(x_1);
+x_5 = l_Lean_Parser_Trie_matchPrefix_loop_match__2___rarg(x_4, x_2, x_3);
+return x_5;
+}
+}
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_1, 1);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_4(x_4, x_5, x_6, x_2, x_3);
+return x_7;
+}
+}
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop_match__3(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_matchPrefix_loop_match__3___rarg), 4, 0);
+return x_3;
+}
+}
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1___rarg(lean_object* x_1, uint32_t x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -10500,15 +11103,15 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; lean_object* x_6; uint8_t x_7; 
@@ -10522,12 +11125,12 @@ if (x_7 == 0)
 {
 lean_object* x_8; uint32_t x_9; lean_object* x_10; lean_object* x_11; 
 lean_inc(x_3);
-x_8 = l___private_Lean_Data_Trie_4__updtAcc___rarg(x_5, x_3, x_4);
+x_8 = l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg(x_5, x_3, x_4);
 lean_dec(x_4);
 x_9 = lean_string_utf8_get(x_1, x_3);
 x_10 = lean_string_utf8_next(x_1, x_3);
 lean_dec(x_3);
-x_11 = l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1___rarg(x_6, x_9);
+x_11 = l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1___rarg(x_6, x_9);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_dec(x_10);
@@ -10549,60 +11152,35 @@ else
 {
 lean_object* x_14; 
 lean_dec(x_6);
-x_14 = l___private_Lean_Data_Trie_4__updtAcc___rarg(x_5, x_3, x_4);
+x_14 = l___private_Lean_Data_Trie_0__Lean_Parser_Trie_updtAcc___rarg(x_5, x_3, x_4);
 lean_dec(x_4);
 return x_14;
 }
 }
 }
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___main(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg___boxed), 4, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_matchPrefix_loop___rarg___boxed), 4, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint32_t x_3; lean_object* x_4; 
 x_3 = lean_unbox_uint32(x_2);
 lean_dec(x_2);
-x_4 = l_Std_RBNode_find___main___at___private_Lean_Data_Trie_5__matchPrefixAux___main___spec__1___rarg(x_1, x_3);
+x_4 = l_Std_RBNode_find___at_Lean_Parser_Trie_matchPrefix_loop___spec__1___rarg(x_1, x_3);
 return x_4;
 }
 }
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Parser_Trie_matchPrefix_loop___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg(x_1, x_2, x_3, x_4);
-lean_dec(x_1);
-return x_5;
-}
-}
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_5__matchPrefixAux___rarg___boxed), 4, 0);
-return x_2;
-}
-}
-lean_object* l___private_Lean_Data_Trie_5__matchPrefixAux___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l___private_Lean_Data_Trie_5__matchPrefixAux___rarg(x_1, x_2, x_3, x_4);
+x_5 = l_Lean_Parser_Trie_matchPrefix_loop___rarg(x_1, x_2, x_3, x_4);
 lean_dec(x_1);
 return x_5;
 }
@@ -10616,7 +11194,7 @@ lean_inc(x_3);
 x_5 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_5, 0, x_3);
 lean_ctor_set(x_5, 1, x_4);
-x_6 = l___private_Lean_Data_Trie_5__matchPrefixAux___main___rarg(x_1, x_2, x_3, x_5);
+x_6 = l_Lean_Parser_Trie_matchPrefix_loop___rarg(x_1, x_2, x_3, x_5);
 return x_6;
 }
 }
@@ -10637,7 +11215,28 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_apply_2(x_2, x_3, x_4);
+return x_5;
+}
+}
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux_match__1___rarg), 2, 0);
+return x_3;
+}
+}
+lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -10668,7 +11267,7 @@ lean_inc(x_6);
 x_7 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_7, 0, x_6);
 lean_ctor_set(x_7, 1, x_2);
-x_8 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_4, x_2);
+x_8 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_4, x_2);
 x_9 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_9, 0, x_7);
 lean_ctor_set(x_9, 1, x_8);
@@ -10677,7 +11276,16 @@ return x_9;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__2___rarg(lean_object* x_1, lean_object* x_2) {
+static lean_object* _init_l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg___closed__1() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = lean_unsigned_to_nat(2u);
+x_2 = lean_nat_to_int(x_1);
+return x_2;
+}
+}
+lean_object* l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -10696,7 +11304,7 @@ lean_inc(x_5);
 x_6 = lean_ctor_get(x_2, 3);
 lean_inc(x_6);
 lean_dec(x_2);
-x_7 = l_Std_RBNode_fold___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__2___rarg(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg(x_1, x_3);
 x_8 = lean_unbox_uint32(x_4);
 lean_dec(x_4);
 x_9 = l_Char_quoteCore(x_8);
@@ -10706,11 +11314,11 @@ lean_dec(x_9);
 x_12 = lean_string_append(x_11, x_10);
 x_13 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_13, 0, x_12);
-x_14 = l___private_Lean_Data_Trie_6__toStringAux___main___rarg(x_5);
+x_14 = l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___rarg(x_5);
 x_15 = lean_box(1);
-x_16 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_14, x_15);
+x_16 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_14, x_15);
 lean_dec(x_14);
-x_17 = l_stdNext___closed__1;
+x_17 = l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg___closed__1;
 x_18 = lean_alloc_ctor(3, 2, 0);
 lean_ctor_set(x_18, 0, x_17);
 lean_ctor_set(x_18, 1, x_16);
@@ -10730,15 +11338,15 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__2(lean_object* x_1) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_fold___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__2___rarg), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg), 2, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Data_Trie_6__toStringAux___main___rarg(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___rarg(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
@@ -10746,61 +11354,45 @@ x_2 = lean_ctor_get(x_1, 1);
 lean_inc(x_2);
 lean_dec(x_1);
 x_3 = lean_box(0);
-x_4 = l_Std_RBNode_fold___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__2___rarg(x_3, x_2);
+x_4 = l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg(x_3, x_2);
 return x_4;
 }
 }
-lean_object* l___private_Lean_Data_Trie_6__toStringAux___main(lean_object* x_1) {
+lean_object* l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_6__toStringAux___main___rarg), 1, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___rarg), 1, 0);
 return x_2;
 }
 }
-lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_1, x_2);
+x_3 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_1, x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l___private_Lean_Data_Trie_6__toStringAux___rarg(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l___private_Lean_Data_Trie_6__toStringAux___main___rarg(x_1);
-return x_2;
-}
-}
-lean_object* l___private_Lean_Data_Trie_6__toStringAux(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Data_Trie_6__toStringAux___rarg), 1, 0);
-return x_2;
-}
-}
-lean_object* l_Lean_Parser_Trie_HasToString___rarg(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__3___rarg(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = l___private_Lean_Data_Trie_6__toStringAux___main___rarg(x_1);
+x_2 = l___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___rarg(x_1);
 x_3 = lean_box(1);
-x_4 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_2, x_3);
+x_4 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_2, x_3);
 lean_dec(x_2);
 x_5 = lean_box(0);
 x_6 = l_Lean_Format_pretty(x_4, x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_Parser_Trie_HasToString(lean_object* x_1) {
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__3(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_HasToString___rarg), 1, 0);
+x_2 = lean_alloc_closure((void*)(l_Lean_Parser_Trie_Lean_Data_Trie___instance__3___rarg), 1, 0);
 return x_2;
 }
 }
@@ -10819,8 +11411,10 @@ if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 l_Lean_Parser_Trie_empty___closed__1 = _init_l_Lean_Parser_Trie_empty___closed__1();
 lean_mark_persistent(l_Lean_Parser_Trie_empty___closed__1);
-l_Lean_Parser_Trie_HasEmptyc___closed__1 = _init_l_Lean_Parser_Trie_HasEmptyc___closed__1();
-lean_mark_persistent(l_Lean_Parser_Trie_HasEmptyc___closed__1);
+l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1 = _init_l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1();
+lean_mark_persistent(l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1);
+l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg___closed__1 = _init_l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg___closed__1();
+lean_mark_persistent(l_Std_RBNode_fold___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__2___rarg___closed__1);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Delaborator.c b/stage0/stdlib/Lean/Delaborator.c
index 6492179284..46b4915f92 100644
--- a/stage0/stdlib/Lean/Delaborator.c
+++ b/stage0/stdlib/Lean/Delaborator.c
@@ -570,7 +570,6 @@ lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lea
 lean_object* l_Lean_Delaborator_failure___rarg___closed__1;
 extern lean_object* l_Lean_throwUnknownConstant___rarg___closed__5;
 lean_object* l_Lean_Delaborator_registerDelabFailureId___closed__2;
-lean_object* l_Std_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Level_getOffsetAux___main(lean_object*, lean_object*);
 lean_object* l_Lean_Delaborator_delabProd___lambda__1___closed__1;
 lean_object* l_Lean_Delaborator_delabHEq___lambda__1___closed__4;
@@ -662,7 +661,6 @@ lean_object* l_Lean_Delaborator_delabLT___lambda__1___closed__3;
 lean_object* l_Lean_Delaborator_mkDelabAttribute___closed__6;
 lean_object* l_Lean_Delaborator_delabNot___closed__1;
 extern lean_object* l_Lean_Meta_reduceNat_x3f___closed__8;
-lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Delaborator_delabFComp___closed__4;
 lean_object* l_Lean_Delaborator_DelabM_monadQuotation;
 lean_object* l_Lean_getPPCoercions___closed__1;
@@ -671,6 +669,7 @@ lean_object* l___regBuiltin_Lean_Delaborator_delabOrM___closed__1;
 lean_object* l___regBuiltin_Lean_Delaborator_delabBNot___closed__1;
 lean_object* l_Lean_Delaborator_delabOfNat___closed__1;
 extern lean_object* l_Lean_Elab_Level_elabLevel___closed__8;
+lean_object* l_Std_RBNode_find___at_Lean_Delaborator_getPPOption___spec__1___boxed(lean_object*, lean_object*);
 size_t l_USize_land(size_t, size_t);
 lean_object* l_Lean_Delaborator_delabGE___lambda__1___closed__2;
 lean_object* l___regBuiltin_Lean_Delaborator_delabLT___closed__2;
@@ -713,6 +712,7 @@ lean_object* l___regBuiltin_Lean_Delaborator_delabMul___closed__4;
 lean_object* l_Lean_Delaborator_failure___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_Delaborator_delabFor___main___spec__3(lean_object*, size_t, lean_object*);
 extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_301____closed__2;
+lean_object* l_Std_RBNode_find___at_Lean_Delaborator_getPPOption___spec__1(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Delaborator_delabMul___closed__1;
 lean_object* l___regBuiltin_Lean_Delaborator_delabCons___closed__3;
 lean_object* l_Lean_Delaborator_getPPOption___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -883,10 +883,8 @@ lean_object* l_Lean_Delaborator_getParamKinds___lambda__1___boxed(lean_object*,
 lean_object* l_Lean_Delaborator_delabSort___closed__9;
 lean_object* l_Lean_Delaborator_delabInfixOp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Delaborator_delabMul___closed__1;
-lean_object* l_Lean_Name_getRoot___main(lean_object*);
 extern lean_object* l_Lean_Meta_evalNat___closed__1;
 lean_object* l_Lean_getPPNotation___closed__2;
-lean_object* l_Std_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Delaborator_delabLit___closed__1;
 lean_object* l___regBuiltin_Lean_Delaborator_delabLT(lean_object*);
 uint8_t l_Lean_Expr_hasLooseBVars(lean_object*);
@@ -1017,6 +1015,7 @@ extern lean_object* l_myMacro____x40_Init_Data_ToString_Macro___hyg_39____closed
 lean_object* l___regBuiltin_Lean_Delaborator_delabTuple___closed__2;
 lean_object* l___regBuiltin_Lean_Delaborator_delabAndThen___closed__2;
 lean_object* l___regBuiltin_Lean_Delaborator_delabPow___closed__1;
+lean_object* l_Lean_Name_getRoot(lean_object*);
 lean_object* l_Lean_Delaborator_delabMapRev(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Delaborator_Alternative___closed__3;
 lean_object* l_Lean_Delaborator_delabNe___lambda__1___closed__3;
@@ -1066,6 +1065,7 @@ lean_object* l_Lean_Delaborator_delabConst___closed__3;
 lean_object* l___regBuiltin_Lean_Delaborator_delabForall(lean_object*);
 lean_object* l_Lean_Delaborator_delabBEq___lambda__1___closed__3;
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Delaborator_hasIdent___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_replacePrefix(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Delaborator_delabBOr___closed__1;
 lean_object* l_Lean_Delaborator_delabLetE___closed__2;
 lean_object* l___private_Lean_Delaborator_3__unresolveOpenDecls___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -4038,7 +4038,7 @@ lean_dec(x_1);
 return x_7;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Delaborator_getPPOption___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -4102,7 +4102,7 @@ lean_inc(x_12);
 lean_dec(x_2);
 x_13 = l_Lean_getPPAll(x_8);
 lean_dec(x_8);
-x_14 = l_Std_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(x_11, x_12);
+x_14 = l_Std_RBNode_find___at_Lean_Delaborator_getPPOption___spec__1(x_11, x_12);
 lean_dec(x_12);
 lean_dec(x_11);
 if (lean_obj_tag(x_14) == 0)
@@ -4158,7 +4158,7 @@ lean_inc(x_26);
 x_27 = lean_ctor_get(x_2, 1);
 lean_inc(x_27);
 lean_dec(x_2);
-x_28 = l_Std_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(x_26, x_27);
+x_28 = l_Std_RBNode_find___at_Lean_Delaborator_getPPOption___spec__1(x_26, x_27);
 lean_dec(x_27);
 lean_dec(x_26);
 if (lean_obj_tag(x_28) == 0)
@@ -4208,11 +4208,11 @@ return x_40;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Delaborator_getPPOption___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Delaborator_getPPOption___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Delaborator_getPPOption___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -8075,7 +8075,7 @@ return x_26;
 else
 {
 lean_object* x_27; 
-x_27 = l_Lean_Name_getRoot___main(x_25);
+x_27 = l_Lean_Name_getRoot(x_25);
 lean_dec(x_25);
 x_1 = x_27;
 x_7 = x_19;
@@ -8656,7 +8656,7 @@ lean_inc(x_11);
 lean_dec(x_8);
 x_12 = l_Lean_NameGenerator_Inhabited___closed__2;
 x_13 = l_Lean_Delaborator_delabMVar___closed__2;
-x_14 = l_Lean_Name_replacePrefix___main(x_11, x_12, x_13);
+x_14 = l_Lean_Name_replacePrefix(x_11, x_12, x_13);
 x_15 = lean_mk_syntax_ident(x_14);
 x_16 = l_Lean_Delaborator_delabMVar___closed__4;
 x_17 = lean_array_push(x_16, x_15);
@@ -8678,7 +8678,7 @@ lean_inc(x_21);
 lean_dec(x_8);
 x_22 = l_Lean_NameGenerator_Inhabited___closed__2;
 x_23 = l_Lean_Delaborator_delabMVar___closed__2;
-x_24 = l_Lean_Name_replacePrefix___main(x_21, x_22, x_23);
+x_24 = l_Lean_Name_replacePrefix(x_21, x_22, x_23);
 x_25 = lean_mk_syntax_ident(x_24);
 x_26 = l_Lean_Delaborator_delabMVar___closed__4;
 x_27 = lean_array_push(x_26, x_25);
@@ -9051,7 +9051,7 @@ _start:
 lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
 x_9 = lean_box(0);
 lean_inc(x_2);
-x_10 = l_Lean_Name_replacePrefix___main(x_2, x_1, x_9);
+x_10 = l_Lean_Name_replacePrefix(x_2, x_1, x_9);
 x_11 = lean_st_ref_get(x_7, x_8);
 x_12 = !lean_is_exclusive(x_11);
 if (x_12 == 0)
@@ -9490,7 +9490,7 @@ x_12 = lean_ctor_get(x_10, 0);
 x_13 = lean_ctor_get(x_10, 1);
 x_14 = lean_box(0);
 lean_inc(x_1);
-x_15 = l_Lean_Name_replacePrefix___main(x_1, x_12, x_14);
+x_15 = l_Lean_Name_replacePrefix(x_1, x_12, x_14);
 x_16 = lean_name_eq(x_15, x_1);
 if (x_16 == 0)
 {
diff --git a/stage0/stdlib/Lean/Elab/App.c b/stage0/stdlib/Lean/Elab/App.c
index b87c755a24..11e43bcc11 100644
--- a/stage0/stdlib/Lean/Elab/App.c
+++ b/stage0/stdlib/Lean/Elab/App.c
@@ -20,12 +20,12 @@ extern lean_object* l___regBuiltin_Lean_Elab_Tactic_evalTacticSeq___closed__2;
 lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_isTypeFormerTypeImp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux___lambda__1___closed__3;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux___lambda__2___closed__1;
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_elabAndAddNewArg_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_getArgExpectedType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_916____spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_elabForall___spec__1___rarg(lean_object*);
 size_t l_USize_add(size_t, size_t);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 extern lean_object* l_Lean_fieldIdxKind;
 lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Elab_Term_elabLetDeclAux___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*);
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -148,6 +148,7 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg_match__2(lea
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_findMethod_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux_match__2(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_processImplicitArg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_processExplictArg___closed__2;
@@ -211,6 +212,7 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppLValsAux_loop___
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_fTypeHasOptAutoParams(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux___closed__7;
 lean_object* l___private_Lean_Util_Trace_3__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_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Util_0__Lean_Elab_evalSyntaxConstantUnsafe(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_ULift_HasRepr___rarg___closed__2;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_getArgExpectedType___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -219,6 +221,7 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_mergeFailures___rarg___
 lean_object* l___private_Lean_Util_Trace_5__getResetTraces___at_Lean_Meta_isLevelDefEq___spec__3___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux___lambda__2___closed__3;
 lean_object* l_Lean_throwError___at_Lean_Meta_getMVarDecl___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_addNamedArg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_isSuccess_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_expandApp_match__2___rarg(lean_object*, lean_object*);
@@ -261,6 +264,7 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppLVals___closed__
 lean_object* l_Lean_Name_append___main(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkArrow___at___private_Lean_Elab_App_0__Lean_Elab_Term_tryCoeFun___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_visit(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___closed__9;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_toMessageData_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -292,11 +296,13 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppFnId___boxed(lea
 lean_object* l_List_forInAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_mkBaseProjections___spec__1___closed__1;
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_unfoldDefinitionImp_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_lengthAux___main___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_expandApp_match__3___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux___lambda__1___closed__4;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppArgs___closed__4;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_processImplicitArg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg(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_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_NamedArg_inhabited___closed__1;
 lean_object* l_Lean_Elab_Term_ElabAppArgs_main_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Arg_hasToString(lean_object*);
@@ -327,6 +333,7 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_toMessageData(lean_obje
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppArgs___closed__2;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValLoop_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_ElabAppArgs_State_instMVars___default;
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_toMessageData_match__1(lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_elabNamedPattern(lean_object*);
 lean_object* l_Lean_Elab_Term_resolveName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -368,7 +375,6 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_addEtaArg(l
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___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*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_getForallBody_match__1(lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppFn___closed__5;
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_toExpr(lean_object*);
 lean_object* l_Lean_Elab_Term_elabChoice(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_Basic_0__Lean_Meta_liftMkBindingM___rarg___closed__3;
@@ -406,7 +412,6 @@ lean_object* l_Lean_MessageData_joinSep___main(lean_object*, lean_object*);
 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___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppLVals(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_toMessageList(lean_object*);
-lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
 extern lean_object* l___regBuiltin_Lean_Elab_Term_elabByTactic___closed__2;
 lean_object* l_Lean_Meta_getLocalDecl___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_hasOptAutoParams(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -460,7 +465,6 @@ extern lean_object* l_Lean_Elab_postponeExceptionId;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_mergeFailures_match__1(lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_mergeFailures___spec__1___closed__1;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___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*, lean_object*);
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_expandApp_match__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg_match__3(lean_object*);
 lean_object* l_Lean_mkApp(lean_object*, lean_object*);
@@ -469,7 +473,6 @@ lean_object* l_Lean_Elab_Term_saveAllState___rarg(lean_object*, lean_object*, le
 lean_object* l_Lean_mkPrivateName(lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValLoop___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppArgs___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*);
-uint8_t l_Lean_Expr_hasMVar(lean_object*);
 lean_object* l_Lean_Elab_Term_SavedState_restore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArgs(lean_object*);
@@ -508,13 +511,13 @@ lean_object* l_Lean_Elab_Term_elabExplicitUniv(lean_object*, lean_object*, lean_
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_processExplictArg___closed__6;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_ElabAppArgs_eraseNamedArgCore(lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabExplicitUnivs___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_processExplictArg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_tryPostponeIfMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setMCtx___at___private_Lean_Meta_Basic_0__Lean_Meta_liftMkBindingM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getPos(lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux_match__4(lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Elab_Term_ElabAppArgs_eraseNamedArg___boxed(lean_object*, 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*);
 lean_object* l_Lean_Elab_getRefPos___at___private_Lean_Elab_App_0__Lean_Elab_Term_toMessageData___spec__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -618,6 +621,7 @@ extern lean_object* l_Nat_Inhabited;
 lean_object* l_Lean_Elab_Term_expandApp___closed__5;
 extern lean_object* l_System_FilePath_dirName___closed__1;
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_contains___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2___boxed(lean_object*, lean_object*);
 uint8_t l_List_isEmpty___rarg(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_applyResult(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -632,7 +636,6 @@ lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ensureArgType(lean_obje
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppFn_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_processExplictArg___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Util___hyg_899____closed__1;
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_isStructureLike(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppFn___closed__4;
 lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_expandApp___spec__1___closed__4;
@@ -662,12 +665,12 @@ lean_object* l_Array_insertAt___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_throwLValError(lean_object*);
 lean_object* l_Lean_findField_x3f___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findIdxAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_addLValArg___spec__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_replacePrefix(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_isNextArgHole___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Elab_Term_ElabAppArgs_State_alreadyPropagated___default;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValLoop_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux___closed__4;
 lean_object* l_Lean_Name_components(lean_object*);
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkAppStx___closed__1;
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppLValsAux_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*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_getForallBody_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -7106,645 +7109,292 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Elab_App_0__Lean_Elab_Term_Ela
 return x_2;
 }
 }
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
+lean_object* x_4; 
+lean_inc(x_1);
+x_4 = lean_alloc_closure((void*)(l_Array_contains___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2___boxed), 2, 1);
+lean_closure_set(x_4, 0, x_1);
 switch (lean_obj_tag(x_2)) {
 case 2:
 {
+lean_dec(x_4);
 if (lean_obj_tag(x_3) == 0)
 {
-lean_object* x_4; uint8_t x_5; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = l_Array_contains___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2(x_1, x_4);
-if (x_5 == 0)
+lean_object* x_5; uint8_t x_6; 
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+lean_dec(x_2);
+x_6 = l_Array_contains___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2(x_1, x_5);
+lean_dec(x_1);
+if (x_6 == 0)
 {
+lean_dec(x_5);
 return x_3;
 }
 else
 {
-lean_object* x_6; 
-lean_inc(x_4);
-x_6 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_6, 0, x_4);
-return x_6;
+lean_object* x_7; 
+x_7 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_7, 0, x_5);
+return x_7;
 }
 }
 else
 {
+lean_dec(x_2);
+lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
 case 5:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_7; lean_object* x_8; uint8_t x_9; 
-x_7 = lean_ctor_get(x_2, 0);
-x_8 = lean_ctor_get(x_2, 1);
-x_9 = l_Lean_Expr_hasMVar(x_7);
-if (x_9 == 0)
-{
-uint8_t x_10; 
-x_10 = l_Lean_Expr_hasMVar(x_8);
-if (x_10 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_8;
-goto _start;
-}
-}
-else
-{
-lean_object* x_12; 
-x_12 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_1, x_7, x_3);
-if (lean_obj_tag(x_12) == 0)
-{
-uint8_t x_13; 
-x_13 = l_Lean_Expr_hasMVar(x_8);
-if (x_13 == 0)
-{
-return x_12;
-}
-else
-{
-x_2 = x_8;
-x_3 = x_12;
-goto _start;
-}
-}
-else
-{
-return x_12;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_2, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_dec(x_2);
+lean_inc(x_4);
+x_10 = l_Lean_FindMVar_visit(x_4, x_8, x_3);
+x_11 = l_Lean_FindMVar_visit(x_4, x_9, x_10);
+lean_dec(x_10);
+return x_11;
 }
 case 6:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_15; lean_object* x_16; uint8_t x_17; 
-x_15 = lean_ctor_get(x_2, 1);
-x_16 = lean_ctor_get(x_2, 2);
-x_17 = l_Lean_Expr_hasMVar(x_15);
-if (x_17 == 0)
-{
-uint8_t x_18; 
-x_18 = l_Lean_Expr_hasMVar(x_16);
-if (x_18 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_16;
-goto _start;
-}
-}
-else
-{
-lean_object* x_20; 
-x_20 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_1, x_15, x_3);
-if (lean_obj_tag(x_20) == 0)
-{
-uint8_t x_21; 
-x_21 = l_Lean_Expr_hasMVar(x_16);
-if (x_21 == 0)
-{
-return x_20;
-}
-else
-{
-x_2 = x_16;
-x_3 = x_20;
-goto _start;
-}
-}
-else
-{
-return x_20;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_dec(x_1);
+x_12 = lean_ctor_get(x_2, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_2, 2);
+lean_inc(x_13);
+lean_dec(x_2);
+lean_inc(x_4);
+x_14 = l_Lean_FindMVar_visit(x_4, x_12, x_3);
+x_15 = l_Lean_FindMVar_visit(x_4, x_13, x_14);
+lean_dec(x_14);
+return x_15;
 }
 case 7:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_23 = lean_ctor_get(x_2, 1);
-x_24 = lean_ctor_get(x_2, 2);
-x_25 = l_Lean_Expr_hasMVar(x_23);
-if (x_25 == 0)
-{
-uint8_t x_26; 
-x_26 = l_Lean_Expr_hasMVar(x_24);
-if (x_26 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_24;
-goto _start;
-}
-}
-else
-{
-lean_object* x_28; 
-x_28 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_1, x_23, x_3);
-if (lean_obj_tag(x_28) == 0)
-{
-uint8_t x_29; 
-x_29 = l_Lean_Expr_hasMVar(x_24);
-if (x_29 == 0)
-{
-return x_28;
-}
-else
-{
-x_2 = x_24;
-x_3 = x_28;
-goto _start;
-}
-}
-else
-{
-return x_28;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_1);
+x_16 = lean_ctor_get(x_2, 1);
+lean_inc(x_16);
+x_17 = lean_ctor_get(x_2, 2);
+lean_inc(x_17);
+lean_dec(x_2);
+lean_inc(x_4);
+x_18 = l_Lean_FindMVar_visit(x_4, x_16, x_3);
+x_19 = l_Lean_FindMVar_visit(x_4, x_17, x_18);
+lean_dec(x_18);
+return x_19;
 }
 case 8:
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_31 = lean_ctor_get(x_2, 1);
-x_32 = lean_ctor_get(x_2, 2);
-x_33 = lean_ctor_get(x_2, 3);
-if (lean_obj_tag(x_3) == 0)
-{
-uint8_t x_42; 
-x_42 = l_Lean_Expr_hasMVar(x_31);
-if (x_42 == 0)
-{
-x_34 = x_3;
-goto block_41;
-}
-else
-{
-lean_object* x_43; 
-x_43 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_1, x_31, x_3);
-if (lean_obj_tag(x_43) == 0)
-{
-x_34 = x_43;
-goto block_41;
-}
-else
-{
-return x_43;
-}
-}
-}
-else
-{
-return x_3;
-}
-block_41:
-{
-uint8_t x_35; 
-x_35 = l_Lean_Expr_hasMVar(x_32);
-if (x_35 == 0)
-{
-if (lean_obj_tag(x_34) == 0)
-{
-uint8_t x_36; 
-x_36 = l_Lean_Expr_hasMVar(x_33);
-if (x_36 == 0)
-{
-return x_34;
-}
-else
-{
-x_2 = x_33;
-x_3 = x_34;
-goto _start;
-}
-}
-else
-{
-return x_34;
-}
-}
-else
-{
-lean_object* x_38; 
-x_38 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_1, x_32, x_34);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = l_Lean_Expr_hasMVar(x_33);
-if (x_39 == 0)
-{
-return x_38;
-}
-else
-{
-x_2 = x_33;
-x_3 = x_38;
-goto _start;
-}
-}
-else
-{
-return x_38;
-}
-}
-}
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_1);
+x_20 = lean_ctor_get(x_2, 1);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_2, 2);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_2, 3);
+lean_inc(x_22);
+lean_dec(x_2);
+lean_inc(x_4);
+x_23 = l_Lean_FindMVar_visit(x_4, x_20, x_3);
+lean_inc(x_4);
+x_24 = l_Lean_FindMVar_visit(x_4, x_21, x_23);
+lean_dec(x_23);
+x_25 = l_Lean_FindMVar_visit(x_4, x_22, x_24);
+lean_dec(x_24);
+return x_25;
 }
 case 10:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_44; uint8_t x_45; 
-x_44 = lean_ctor_get(x_2, 1);
-x_45 = l_Lean_Expr_hasMVar(x_44);
-if (x_45 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_44;
-goto _start;
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_26; lean_object* x_27; 
+lean_dec(x_1);
+x_26 = lean_ctor_get(x_2, 1);
+lean_inc(x_26);
+lean_dec(x_2);
+x_27 = l_Lean_FindMVar_visit(x_4, x_26, x_3);
+return x_27;
 }
 case 11:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_2, 2);
-x_48 = l_Lean_Expr_hasMVar(x_47);
-if (x_48 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_47;
-goto _start;
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_28; lean_object* x_29; 
+lean_dec(x_1);
+x_28 = lean_ctor_get(x_2, 2);
+lean_inc(x_28);
+lean_dec(x_2);
+x_29 = l_Lean_FindMVar_visit(x_4, x_28, x_3);
+return x_29;
 }
 default: 
 {
+lean_dec(x_4);
+lean_dec(x_2);
+lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
 }
 }
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+uint8_t l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
+uint8_t x_3; 
+x_3 = l_Array_contains___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2(x_1, x_2);
+if (x_3 == 0)
+{
+uint8_t x_4; 
+x_4 = 1;
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+x_5 = 0;
+return x_5;
+}
+}
+}
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+lean_inc(x_1);
+x_4 = lean_alloc_closure((void*)(l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___lambda__1___boxed), 2, 1);
+lean_closure_set(x_4, 0, x_1);
 switch (lean_obj_tag(x_2)) {
 case 2:
 {
+lean_dec(x_4);
 if (lean_obj_tag(x_3) == 0)
 {
-lean_object* x_4; uint8_t x_5; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = l_Array_contains___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2(x_1, x_4);
-if (x_5 == 0)
+lean_object* x_5; uint8_t x_6; 
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+lean_dec(x_2);
+x_6 = l_Array_contains___at_Lean_Elab_Term_logUnassignedUsingErrorInfos___spec__2(x_1, x_5);
+lean_dec(x_1);
+if (x_6 == 0)
 {
-lean_object* x_6; 
-lean_inc(x_4);
-x_6 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_6, 0, x_4);
-return x_6;
+lean_object* x_7; 
+x_7 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_7, 0, x_5);
+return x_7;
 }
 else
 {
+lean_dec(x_5);
 return x_3;
 }
 }
 else
 {
+lean_dec(x_2);
+lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
 case 5:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_7; lean_object* x_8; uint8_t x_9; 
-x_7 = lean_ctor_get(x_2, 0);
-x_8 = lean_ctor_get(x_2, 1);
-x_9 = l_Lean_Expr_hasMVar(x_7);
-if (x_9 == 0)
-{
-uint8_t x_10; 
-x_10 = l_Lean_Expr_hasMVar(x_8);
-if (x_10 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_8;
-goto _start;
-}
-}
-else
-{
-lean_object* x_12; 
-x_12 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_1, x_7, x_3);
-if (lean_obj_tag(x_12) == 0)
-{
-uint8_t x_13; 
-x_13 = l_Lean_Expr_hasMVar(x_8);
-if (x_13 == 0)
-{
-return x_12;
-}
-else
-{
-x_2 = x_8;
-x_3 = x_12;
-goto _start;
-}
-}
-else
-{
-return x_12;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_2, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_2, 1);
+lean_inc(x_9);
+lean_dec(x_2);
+lean_inc(x_4);
+x_10 = l_Lean_FindMVar_visit(x_4, x_8, x_3);
+x_11 = l_Lean_FindMVar_visit(x_4, x_9, x_10);
+lean_dec(x_10);
+return x_11;
 }
 case 6:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_15; lean_object* x_16; uint8_t x_17; 
-x_15 = lean_ctor_get(x_2, 1);
-x_16 = lean_ctor_get(x_2, 2);
-x_17 = l_Lean_Expr_hasMVar(x_15);
-if (x_17 == 0)
-{
-uint8_t x_18; 
-x_18 = l_Lean_Expr_hasMVar(x_16);
-if (x_18 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_16;
-goto _start;
-}
-}
-else
-{
-lean_object* x_20; 
-x_20 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_1, x_15, x_3);
-if (lean_obj_tag(x_20) == 0)
-{
-uint8_t x_21; 
-x_21 = l_Lean_Expr_hasMVar(x_16);
-if (x_21 == 0)
-{
-return x_20;
-}
-else
-{
-x_2 = x_16;
-x_3 = x_20;
-goto _start;
-}
-}
-else
-{
-return x_20;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+lean_dec(x_1);
+x_12 = lean_ctor_get(x_2, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_2, 2);
+lean_inc(x_13);
+lean_dec(x_2);
+lean_inc(x_4);
+x_14 = l_Lean_FindMVar_visit(x_4, x_12, x_3);
+x_15 = l_Lean_FindMVar_visit(x_4, x_13, x_14);
+lean_dec(x_14);
+return x_15;
 }
 case 7:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_23 = lean_ctor_get(x_2, 1);
-x_24 = lean_ctor_get(x_2, 2);
-x_25 = l_Lean_Expr_hasMVar(x_23);
-if (x_25 == 0)
-{
-uint8_t x_26; 
-x_26 = l_Lean_Expr_hasMVar(x_24);
-if (x_26 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_24;
-goto _start;
-}
-}
-else
-{
-lean_object* x_28; 
-x_28 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_1, x_23, x_3);
-if (lean_obj_tag(x_28) == 0)
-{
-uint8_t x_29; 
-x_29 = l_Lean_Expr_hasMVar(x_24);
-if (x_29 == 0)
-{
-return x_28;
-}
-else
-{
-x_2 = x_24;
-x_3 = x_28;
-goto _start;
-}
-}
-else
-{
-return x_28;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_1);
+x_16 = lean_ctor_get(x_2, 1);
+lean_inc(x_16);
+x_17 = lean_ctor_get(x_2, 2);
+lean_inc(x_17);
+lean_dec(x_2);
+lean_inc(x_4);
+x_18 = l_Lean_FindMVar_visit(x_4, x_16, x_3);
+x_19 = l_Lean_FindMVar_visit(x_4, x_17, x_18);
+lean_dec(x_18);
+return x_19;
 }
 case 8:
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_31 = lean_ctor_get(x_2, 1);
-x_32 = lean_ctor_get(x_2, 2);
-x_33 = lean_ctor_get(x_2, 3);
-if (lean_obj_tag(x_3) == 0)
-{
-uint8_t x_42; 
-x_42 = l_Lean_Expr_hasMVar(x_31);
-if (x_42 == 0)
-{
-x_34 = x_3;
-goto block_41;
-}
-else
-{
-lean_object* x_43; 
-x_43 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_1, x_31, x_3);
-if (lean_obj_tag(x_43) == 0)
-{
-x_34 = x_43;
-goto block_41;
-}
-else
-{
-return x_43;
-}
-}
-}
-else
-{
-return x_3;
-}
-block_41:
-{
-uint8_t x_35; 
-x_35 = l_Lean_Expr_hasMVar(x_32);
-if (x_35 == 0)
-{
-if (lean_obj_tag(x_34) == 0)
-{
-uint8_t x_36; 
-x_36 = l_Lean_Expr_hasMVar(x_33);
-if (x_36 == 0)
-{
-return x_34;
-}
-else
-{
-x_2 = x_33;
-x_3 = x_34;
-goto _start;
-}
-}
-else
-{
-return x_34;
-}
-}
-else
-{
-lean_object* x_38; 
-x_38 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_1, x_32, x_34);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = l_Lean_Expr_hasMVar(x_33);
-if (x_39 == 0)
-{
-return x_38;
-}
-else
-{
-x_2 = x_33;
-x_3 = x_38;
-goto _start;
-}
-}
-else
-{
-return x_38;
-}
-}
-}
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_1);
+x_20 = lean_ctor_get(x_2, 1);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_2, 2);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_2, 3);
+lean_inc(x_22);
+lean_dec(x_2);
+lean_inc(x_4);
+x_23 = l_Lean_FindMVar_visit(x_4, x_20, x_3);
+lean_inc(x_4);
+x_24 = l_Lean_FindMVar_visit(x_4, x_21, x_23);
+lean_dec(x_23);
+x_25 = l_Lean_FindMVar_visit(x_4, x_22, x_24);
+lean_dec(x_24);
+return x_25;
 }
 case 10:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_44; uint8_t x_45; 
-x_44 = lean_ctor_get(x_2, 1);
-x_45 = l_Lean_Expr_hasMVar(x_44);
-if (x_45 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_44;
-goto _start;
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_26; lean_object* x_27; 
+lean_dec(x_1);
+x_26 = lean_ctor_get(x_2, 1);
+lean_inc(x_26);
+lean_dec(x_2);
+x_27 = l_Lean_FindMVar_visit(x_4, x_26, x_3);
+return x_27;
 }
 case 11:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_2, 2);
-x_48 = l_Lean_Expr_hasMVar(x_47);
-if (x_48 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_47;
-goto _start;
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_28; lean_object* x_29; 
+lean_dec(x_1);
+x_28 = lean_ctor_get(x_2, 2);
+lean_inc(x_28);
+lean_dec(x_2);
+x_29 = l_Lean_FindMVar_visit(x_4, x_28, x_3);
+return x_29;
 }
 default: 
 {
+lean_dec(x_4);
+lean_dec(x_2);
+lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
@@ -9586,9 +9236,11 @@ if (x_33 == 0)
 {
 lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; 
 x_34 = lean_box(0);
-x_35 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_16, x_32, x_34);
-x_36 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_16, x_32, x_34);
-lean_dec(x_16);
+lean_inc(x_32);
+lean_inc(x_16);
+x_35 = l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_16, x_32, x_34);
+lean_inc(x_32);
+x_36 = l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_16, x_32, x_34);
 if (lean_obj_tag(x_35) == 0)
 {
 uint8_t x_267; 
@@ -10640,7 +10292,7 @@ lean_inc(x_282);
 lean_dec(x_272);
 x_283 = lean_array_get_size(x_15);
 lean_dec(x_15);
-x_284 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_283);
+x_284 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_283);
 x_285 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_285, 0, x_284);
 x_286 = l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___closed__5;
@@ -10652,7 +10304,7 @@ x_289 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_289, 0, x_287);
 lean_ctor_set(x_289, 1, x_288);
 lean_inc(x_23);
-x_290 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_23);
+x_290 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_23);
 x_291 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_291, 0, x_290);
 x_292 = lean_alloc_ctor(10, 2, 0);
@@ -10849,9 +10501,11 @@ if (x_344 == 0)
 {
 lean_object* x_345; lean_object* x_346; lean_object* x_347; uint8_t x_348; 
 x_345 = lean_box(0);
-x_346 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_326, x_343, x_345);
-x_347 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_326, x_343, x_345);
-lean_dec(x_326);
+lean_inc(x_343);
+lean_inc(x_326);
+x_346 = l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_326, x_343, x_345);
+lean_inc(x_343);
+x_347 = l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_326, x_343, x_345);
 if (lean_obj_tag(x_346) == 0)
 {
 uint8_t x_434; 
@@ -11338,7 +10992,7 @@ lean_inc(x_447);
 lean_dec(x_439);
 x_448 = lean_array_get_size(x_323);
 lean_dec(x_323);
-x_449 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_448);
+x_449 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_448);
 x_450 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_450, 0, x_449);
 x_451 = l___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___closed__5;
@@ -11350,7 +11004,7 @@ x_454 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_454, 0, x_452);
 lean_ctor_set(x_454, 1, x_453);
 lean_inc(x_334);
-x_455 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_334);
+x_455 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_334);
 x_456 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_456, 0, x_455);
 x_457 = lean_alloc_ctor(10, 2, 0);
@@ -11406,23 +11060,32 @@ return x_484;
 }
 }
 }
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_1, x_2, x_3);
-lean_dec(x_2);
-lean_dec(x_1);
+x_4 = l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__1(x_1, x_2, x_3);
+lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___lambda__1(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_FindMVar_main___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_1, x_2, x_3);
-lean_dec(x_2);
-lean_dec(x_1);
+x_4 = l_Lean_FindMVar_main___at___private_Lean_Elab_App_0__Lean_Elab_Term_ElabAppArgs_propagateExpectedType___spec__2(x_1, x_2, x_3);
+lean_dec(x_3);
 return x_4;
 }
 }
@@ -16001,7 +15664,7 @@ lean_dec(x_16);
 lean_dec(x_14);
 lean_dec(x_2);
 lean_dec(x_1);
-x_19 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_17);
+x_19 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_17);
 x_20 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_20, 0, x_19);
 x_21 = l___private_Lean_Elab_App_0__Lean_Elab_Term_resolveLValAux___lambda__1___closed__2;
@@ -16367,7 +16030,7 @@ x_33 = lean_ctor_get(x_4, 2);
 lean_inc(x_33);
 x_34 = lean_box(0);
 lean_inc(x_32);
-x_35 = l_Lean_Name_replacePrefix___main(x_32, x_33, x_34);
+x_35 = l_Lean_Name_replacePrefix(x_32, x_33, x_34);
 lean_dec(x_33);
 x_36 = lean_ctor_get(x_6, 1);
 lean_inc(x_36);
@@ -16540,7 +16203,7 @@ x_79 = lean_name_mk_string(x_24, x_25);
 x_80 = lean_ctor_get(x_4, 2);
 lean_inc(x_80);
 lean_inc(x_79);
-x_81 = l_Lean_Name_replacePrefix___main(x_79, x_80, x_76);
+x_81 = l_Lean_Name_replacePrefix(x_79, x_80, x_76);
 lean_dec(x_80);
 x_82 = lean_ctor_get(x_6, 1);
 lean_inc(x_82);
@@ -16737,7 +16400,7 @@ x_127 = lean_ctor_get(x_4, 2);
 lean_inc(x_127);
 x_128 = lean_box(0);
 lean_inc(x_126);
-x_129 = l_Lean_Name_replacePrefix___main(x_126, x_127, x_128);
+x_129 = l_Lean_Name_replacePrefix(x_126, x_127, x_128);
 lean_dec(x_127);
 x_130 = lean_ctor_get(x_6, 1);
 lean_inc(x_130);
@@ -16914,7 +16577,7 @@ x_176 = lean_name_mk_string(x_24, x_25);
 x_177 = lean_ctor_get(x_4, 2);
 lean_inc(x_177);
 lean_inc(x_176);
-x_178 = l_Lean_Name_replacePrefix___main(x_176, x_177, x_173);
+x_178 = l_Lean_Name_replacePrefix(x_176, x_177, x_173);
 lean_dec(x_177);
 x_179 = lean_ctor_get(x_6, 1);
 lean_inc(x_179);
@@ -27012,7 +26675,7 @@ x_17 = lean_ctor_get(x_2, 1);
 x_18 = l_Lean_FileMap_toPosition(x_17, x_15);
 x_19 = lean_ctor_get(x_18, 0);
 lean_inc(x_19);
-x_20 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_19);
+x_20 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_19);
 x_21 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_21, 0, x_20);
 x_22 = l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
@@ -27026,7 +26689,7 @@ lean_ctor_set(x_25, 1, x_24);
 x_26 = lean_ctor_get(x_18, 1);
 lean_inc(x_26);
 lean_dec(x_18);
-x_27 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_26);
+x_27 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_26);
 x_28 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_28, 0, x_27);
 x_29 = lean_alloc_ctor(10, 2, 0);
@@ -27092,7 +26755,7 @@ x_44 = lean_ctor_get(x_2, 1);
 x_45 = l_Lean_FileMap_toPosition(x_44, x_42);
 x_46 = lean_ctor_get(x_45, 0);
 lean_inc(x_46);
-x_47 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_46);
+x_47 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_46);
 x_48 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_48, 0, x_47);
 x_49 = l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
@@ -27106,7 +26769,7 @@ lean_ctor_set(x_52, 1, x_51);
 x_53 = lean_ctor_get(x_45, 1);
 lean_inc(x_53);
 lean_dec(x_45);
-x_54 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_53);
+x_54 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_53);
 x_55 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_55, 0, x_54);
 x_56 = lean_alloc_ctor(10, 2, 0);
@@ -27260,7 +26923,7 @@ x_1 = l_Array_umapMAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_mer
 x_2 = l_Array_umapMAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_mergeFailures___spec__1___closed__2;
 x_3 = lean_unsigned_to_nat(768u);
 x_4 = lean_unsigned_to_nat(33u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -27529,7 +27192,7 @@ x_1 = l_Array_umapMAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_mer
 x_2 = l_Array_umapMAux___main___at___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppAux___spec__1___closed__1;
 x_3 = lean_unsigned_to_nat(788u);
 x_4 = lean_unsigned_to_nat(33u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Elab/Binders.c b/stage0/stdlib/Lean/Elab/Binders.c
index ee4629031a..497ddf705f 100644
--- a/stage0/stdlib/Lean/Elab/Binders.c
+++ b/stage0/stdlib/Lean/Elab/Binders.c
@@ -26,6 +26,7 @@ lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_elabForall__
 lean_object* l_Lean_Meta_withLCtx___at___private_Lean_Elab_Binders_0__Lean_Elab_Term_elabBinderViews___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandMatchAltsIntoMatchAux___closed__10;
 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_elabLetDecl(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_Term_elabLetDeclAux___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*);
 lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__3;
@@ -373,7 +374,6 @@ lean_object* l_Lean_Meta_setMCtx___at___private_Lean_Meta_Basic_0__Lean_Meta_lif
 uint8_t l_Lean_Elab_Term_Quotation_isAntiquotSplice(lean_object*);
 lean_object* l_Lean_Elab_Term_FunBinders_elabFunBindersAux___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_elabLetDeclCore___closed__10;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 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_Array_myMacro____x40_Init_Data_Array_Macros___hyg_464____closed__11;
@@ -970,7 +970,7 @@ x_1 = l_Lean_Elab_Term_quoteAutoTactic___closed__1;
 x_2 = l_Lean_Elab_Term_quoteAutoTactic___closed__2;
 x_3 = lean_unsigned_to_nat(55u);
 x_4 = lean_unsigned_to_nat(26u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -19756,7 +19756,7 @@ x_1 = l_Lean_Elab_Term_quoteAutoTactic___closed__1;
 x_2 = l_Lean_Elab_Term_elabLetDeclCore___closed__7;
 x_3 = lean_unsigned_to_nat(517u);
 x_4 = lean_unsigned_to_nat(22u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Elab/BuiltinNotation.c b/stage0/stdlib/Lean/Elab/BuiltinNotation.c
index fef0373307..7d8515159f 100644
--- a/stage0/stdlib/Lean/Elab/BuiltinNotation.c
+++ b/stage0/stdlib/Lean/Elab/BuiltinNotation.c
@@ -282,7 +282,6 @@ lean_object* l___regBuiltin_Lean_Elab_Term_expandGE___closed__2;
 lean_object* l_Lean_Elab_Term_expandEmptyC___closed__5;
 extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_301____closed__5;
 lean_object* l___regBuiltin_Lean_Elab_Term_expandseqLeft___closed__2;
-extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15;
 extern lean_object* l_Lean_myMacro____x40_Lean_Util_Trace___hyg_45____closed__7;
 lean_object* l___regBuiltin_Lean_Elab_Term_expandAdd___closed__2;
 lean_object* l___regBuiltin_Lean_Elab_Term_expandHave___closed__1;
@@ -359,6 +358,7 @@ lean_object* l_Lean_Elab_Term_expandGE___boxed(lean_object*, lean_object*, lean_
 lean_object* l_Lean_Meta_mkExpectedTypeHint___at_Lean_Elab_Term_elabNativeRefl___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabPanic___closed__5;
 lean_object* l_Lean_Elab_Term_expandEquiv___closed__2;
+extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
 lean_object* l_Lean_Elab_Term_expandShow___closed__5;
 lean_object* l_Lean_Elab_Term_expandShow___closed__15;
 lean_object* l_Lean_Elab_Term_expandEquiv___closed__1;
@@ -441,6 +441,7 @@ lean_object* l_Lean_compileDecl___at_Lean_Elab_Term_declareTacticSyntax___spec__
 lean_object* l_Lean_Elab_Term_elabPanic___closed__11;
 lean_object* l_Lean_Elab_Term_expandDiv___closed__3;
 lean_object* l___regBuiltin_Lean_Elab_Term_elabBorrowed(lean_object*);
+extern lean_object* l_Lean_setOptionFromString___closed__5;
 lean_object* l_Lean_Elab_Term_expandPow___closed__4;
 lean_object* l_Lean_Elab_Term_expandAssert___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -461,7 +462,6 @@ lean_object* l___private_Lean_Elab_BuiltinNotation_0__Lean_Elab_Term_mkNativeRef
 extern lean_object* l_Lean_Meta_reduceNat_x3f___closed__8;
 lean_object* l___private_Lean_Elab_BuiltinNotation_0__Lean_Elab_Term_elabParserMacroAux___closed__22;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
 extern lean_object* l_Lean_myMacro____x40_Lean_Util_Trace___hyg_45____closed__13;
 extern lean_object* l___regBuiltin_Lean_Elab_Term_elabByTactic___closed__2;
 lean_object* l_Lean_Elab_Term_expandAppend___closed__2;
@@ -515,6 +515,7 @@ extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_
 lean_object* l_Lean_Elab_Term_elabNativeRefl_match__1(lean_object*);
 lean_object* l_Lean_Elab_Term_expandShow___closed__13;
 extern lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__7;
+extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
 lean_object* l___private_Lean_Elab_BuiltinNotation_0__Lean_Elab_Term_elabTParserMacroAux___closed__7;
 lean_object* l___regBuiltin_Lean_Elab_Term_expandShow(lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_expandSubtype___closed__1;
@@ -631,7 +632,6 @@ lean_object* l_List_beq___main___at___private_Lean_Elab_BuiltinNotation_0__Lean_
 lean_object* l_Lean_Elab_Term_expandBOr(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabPanic___closed__9;
 extern lean_object* l_Lean_Meta_mkSorry___rarg___lambda__1___closed__1;
-lean_object* l_Lean_Elab_Term_expandSorry___rarg___closed__9;
 lean_object* l___regBuiltin_Lean_Elab_Term_expandMapRev___closed__2;
 lean_object* l_Lean_Elab_Term_elabPanic___closed__1;
 lean_object* l_Lean_Elab_Term_expandShow___closed__4;
@@ -11101,10 +11101,10 @@ if (lean_obj_tag(x_8) == 0)
 lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
 x_9 = l_Lean_Elab_Term_expandAssert___closed__1;
 x_10 = lean_array_push(x_9, x_5);
-x_11 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
+x_11 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
 x_12 = lean_array_push(x_10, x_11);
 x_13 = lean_array_push(x_12, x_7);
-x_14 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15;
+x_14 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
 x_15 = lean_array_push(x_13, x_14);
 x_16 = l_Lean_Elab_Term_expandAssert___closed__13;
 x_17 = lean_array_push(x_15, x_16);
@@ -11125,10 +11125,10 @@ lean_inc(x_21);
 lean_dec(x_8);
 x_22 = l_Lean_Elab_Term_expandAssert___closed__1;
 x_23 = lean_array_push(x_22, x_5);
-x_24 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
+x_24 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
 x_25 = lean_array_push(x_23, x_24);
 x_26 = lean_array_push(x_25, x_7);
-x_27 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15;
+x_27 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
 x_28 = lean_array_push(x_26, x_27);
 x_29 = l_Lean_SourceInfo_inhabited___closed__1;
 x_30 = l_Lean_mkStxStrLit(x_21, x_29);
@@ -11637,8 +11637,10 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Bool_HasRepr___closed__1;
-x_3 = lean_name_mk_string(x_1, x_2);
+x_2 = l_Lean_boolToExpr___lambda__1___closed__3;
+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;
 }
 }
@@ -11647,19 +11649,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_boolToExpr___lambda__1___closed__3;
-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_Lean_Elab_Term_expandSorry___rarg___closed__9() {
-_start:
-{
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Term_expandSorry___rarg___closed__8;
+x_2 = l_Lean_Elab_Term_expandSorry___rarg___closed__7;
 x_3 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
@@ -11689,10 +11679,10 @@ lean_ctor_set(x_10, 2, x_6);
 lean_ctor_set(x_10, 3, x_9);
 x_11 = l_Array_empty___closed__1;
 x_12 = lean_array_push(x_11, x_10);
-x_13 = l_Lean_Elab_Term_expandSorry___rarg___closed__7;
+x_13 = l_Lean_setOptionFromString___closed__5;
 x_14 = l_Lean_addMacroScope(x_4, x_13, x_3);
 x_15 = l_Lean_Elab_Term_expandSorry___rarg___closed__6;
-x_16 = l_Lean_Elab_Term_expandSorry___rarg___closed__9;
+x_16 = l_Lean_Elab_Term_expandSorry___rarg___closed__8;
 x_17 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_17, 0, x_7);
 lean_ctor_set(x_17, 1, x_15);
@@ -12924,8 +12914,6 @@ l_Lean_Elab_Term_expandSorry___rarg___closed__7 = _init_l_Lean_Elab_Term_expandS
 lean_mark_persistent(l_Lean_Elab_Term_expandSorry___rarg___closed__7);
 l_Lean_Elab_Term_expandSorry___rarg___closed__8 = _init_l_Lean_Elab_Term_expandSorry___rarg___closed__8();
 lean_mark_persistent(l_Lean_Elab_Term_expandSorry___rarg___closed__8);
-l_Lean_Elab_Term_expandSorry___rarg___closed__9 = _init_l_Lean_Elab_Term_expandSorry___rarg___closed__9();
-lean_mark_persistent(l_Lean_Elab_Term_expandSorry___rarg___closed__9);
 l___regBuiltin_Lean_Elab_Term_expandSorry___closed__1 = _init_l___regBuiltin_Lean_Elab_Term_expandSorry___closed__1();
 lean_mark_persistent(l___regBuiltin_Lean_Elab_Term_expandSorry___closed__1);
 l___regBuiltin_Lean_Elab_Term_expandSorry___closed__2 = _init_l___regBuiltin_Lean_Elab_Term_expandSorry___closed__2();
diff --git a/stage0/stdlib/Lean/Elab/Command.c b/stage0/stdlib/Lean/Elab/Command.c
index 6c74fd1ba5..34b9c7dfe6 100644
--- a/stage0/stdlib/Lean/Elab/Command.c
+++ b/stage0/stdlib/Lean/Elab/Command.c
@@ -28,6 +28,7 @@ lean_object* l___private_Lean_Elab_Command_0__Lean_Elab_Command_addNamespace(lea
 lean_object* l___regBuiltin_Lean_Elab_Command_elabEval___closed__3;
 lean_object* l_Lean_extractMacroScopes(lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Elab_Command_0__Lean_Elab_Command_elabCommandUsing___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_checkNotAlreadyDeclared___at_Lean_Elab_Command_expandDeclId___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_Lean_Elab_Command___instance__7___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -108,7 +109,6 @@ lean_object* l___private_Lean_Elab_Command_0__Lean_Elab_Command_addNamespace___b
 lean_object* l_Lean_addMessageContextPartial___at_Lean_Elab_Command_Lean_Elab_Command___instance__3___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_addAndCompile___at_Lean_Elab_Command_elabEvalUnsafe___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
-extern lean_object* l_Lean_verboseOption___closed__3;
 lean_object* l_Lean_Elab_Command_CommandElabM_monadLog___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_withLogging___closed__2;
 lean_object* l_Lean_Elab_Command_hasNoErrorMessages___rarg___boxed(lean_object*, lean_object*);
@@ -204,7 +204,6 @@ lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_obj
 lean_object* l_Lean_Elab_Command_elabEvalUnsafe_match__2___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Command_0__Lean_Elab_Command_elabCommandUsing_match__1(lean_object*);
 lean_object* l_Lean_Elab_Command_failIfSucceeds___lambda__1___closed__2;
-lean_object* l_Lean_Name_getNumParts___main(lean_object*);
 lean_object* l_Lean_Elab_Command_elabOpen___closed__3;
 lean_object* l_Lean_Elab_Command_elabOpen(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Command_elabOpen___closed__3;
@@ -381,7 +380,6 @@ lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_expandDeclId___at_Lean_Elab_Command_expandDeclId___spec__1___boxed(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*);
 lean_object* l_Lean_Elab_Command_mkCommandElabAttributeUnsafe___closed__5;
-lean_object* l_Lean_KVMap_insertCore___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_runTermElabM___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_Command_0__Lean_Elab_Command_addTraceAsMessages___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Elab_Command_elabCommand___spec__6___boxed(lean_object*, lean_object*);
@@ -405,6 +403,7 @@ lean_object* l_Lean_Elab_Command_elabExport(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_Elab_Command_elabSynth___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabCheck___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabOpenOnly(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Name_getNumParts(lean_object*);
 lean_object* l_Lean_Elab_Command_hasNoErrorMessages(lean_object*);
 lean_object* l_Lean_SMap_find_x3f___at_Lean_Elab_Command_elabCommand___spec__1(lean_object*, lean_object*);
 extern lean_object* l_IO_Error_Inhabited___closed__1;
@@ -579,10 +578,12 @@ lean_object* l_Lean_Elab_Command_setOption_match__1___rarg(lean_object*, lean_ob
 lean_object* lean_panic_fn(lean_object*, lean_object*);
 extern lean_object* l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
 lean_object* l_Lean_Meta_withLocalDecl___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabImplicitLambda___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3;
 lean_object* l___private_Lean_Elab_Command_0__Lean_Elab_Command_ioErrorToMessage___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_mkCommandElabAttributeUnsafe___closed__2;
 lean_object* l_Lean_Elab_Command_modifyScope___at_Lean_Elab_Command_setOption___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_resolveNamespace___rarg___lambda__1___closed__1;
+lean_object* l_Lean_KVMap_insertCore(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_evalConst___at_Lean_Elab_Command_elabEvalUnsafe___spec__2(lean_object*);
 lean_object* l_Lean_Elab_Command_Lean_Elab_Command___instance__9___closed__1;
 lean_object* l_Lean_throwErrorAt___at_Lean_Elab_Command_elabCommand___spec__8___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -607,7 +608,6 @@ lean_object* l_Lean_Elab_Command_mkCommandElabAttributeUnsafe___closed__3;
 lean_object* l_Lean_Syntax_getPos(lean_object*);
 lean_object* l_Lean_Elab_Command_getRef(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_State_inhabited;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Std_PersistentArray_foldlMAux___at___private_Lean_Elab_Command_0__Lean_Elab_Command_addTraceAsMessages___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_expandDeclId___at_Lean_Elab_Command_expandDeclId___spec__1(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*);
@@ -9113,7 +9113,7 @@ lean_inc(x_77);
 x_78 = lean_ctor_get(x_8, 1);
 lean_inc(x_78);
 lean_dec(x_8);
-x_79 = l_Lean_Name_getNumParts___main(x_76);
+x_79 = l_Lean_Name_getNumParts(x_76);
 lean_dec(x_76);
 x_9 = x_79;
 x_10 = x_77;
@@ -9398,7 +9398,7 @@ if (x_16 == 0)
 {
 lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; 
 x_17 = lean_ctor_get(x_14, 2);
-x_18 = l_Lean_Name_getNumParts___main(x_1);
+x_18 = l_Lean_Name_getNumParts(x_1);
 lean_dec(x_1);
 x_19 = l_List_drop___main___rarg(x_18, x_17);
 lean_dec(x_17);
@@ -9444,7 +9444,7 @@ lean_inc(x_27);
 lean_inc(x_26);
 lean_inc(x_25);
 lean_dec(x_14);
-x_32 = l_Lean_Name_getNumParts___main(x_1);
+x_32 = l_Lean_Name_getNumParts(x_1);
 lean_dec(x_1);
 x_33 = l_List_drop___main___rarg(x_32, x_27);
 lean_dec(x_27);
@@ -9596,7 +9596,7 @@ x_1 = l_Lean_Elab_Command_modifyScope___closed__1;
 x_2 = l_Lean_Elab_Command_modifyScope___closed__2;
 x_3 = lean_unsigned_to_nat(343u);
 x_4 = lean_unsigned_to_nat(14u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -17729,7 +17729,7 @@ if (x_43 == 0)
 {
 lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; 
 x_44 = lean_ctor_get(x_37, 2);
-x_45 = l_Lean_KVMap_insertCore___main(x_44, x_1, x_2);
+x_45 = l_Lean_KVMap_insertCore(x_44, x_1, x_2);
 lean_ctor_set(x_37, 2, x_45);
 x_46 = lean_st_ref_set(x_4, x_7, x_38);
 x_47 = !lean_is_exclusive(x_46);
@@ -17773,7 +17773,7 @@ lean_inc(x_55);
 lean_inc(x_54);
 lean_inc(x_53);
 lean_dec(x_37);
-x_60 = l_Lean_KVMap_insertCore___main(x_55, x_1, x_2);
+x_60 = l_Lean_KVMap_insertCore(x_55, x_1, x_2);
 x_61 = lean_alloc_ctor(0, 7, 0);
 lean_ctor_set(x_61, 0, x_53);
 lean_ctor_set(x_61, 1, x_54);
@@ -17838,7 +17838,7 @@ if (lean_is_exclusive(x_37)) {
  lean_dec_ref(x_37);
  x_75 = lean_box(0);
 }
-x_76 = l_Lean_KVMap_insertCore___main(x_70, x_1, x_2);
+x_76 = l_Lean_KVMap_insertCore(x_70, x_1, x_2);
 if (lean_is_scalar(x_75)) {
  x_77 = lean_alloc_ctor(0, 7, 0);
 } else {
@@ -17930,7 +17930,7 @@ if (lean_is_exclusive(x_37)) {
  lean_dec_ref(x_37);
  x_99 = lean_box(0);
 }
-x_100 = l_Lean_KVMap_insertCore___main(x_94, x_1, x_2);
+x_100 = l_Lean_KVMap_insertCore(x_94, x_1, x_2);
 if (lean_is_scalar(x_99)) {
  x_101 = lean_alloc_ctor(0, 7, 0);
 } else {
@@ -18660,7 +18660,7 @@ else
 lean_object* x_27; lean_object* x_28; 
 lean_dec(x_13);
 lean_dec(x_9);
-x_27 = l_Lean_verboseOption___closed__3;
+x_27 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3;
 x_28 = l_Lean_Elab_Command_setOption(x_7, x_27, x_2, x_3, x_4);
 return x_28;
 }
diff --git a/stage0/stdlib/Lean/Elab/DeclModifiers.c b/stage0/stdlib/Lean/Elab/DeclModifiers.c
index 08ee7c034b..31c77cd314 100644
--- a/stage0/stdlib/Lean/Elab/DeclModifiers.c
+++ b/stage0/stdlib/Lean/Elab/DeclModifiers.c
@@ -72,7 +72,6 @@ lean_object* l_Lean_Elab_Modifiers_hasFormat(lean_object*);
 lean_object* l_Lean_Elab_expandDeclId_match__2(lean_object*);
 lean_object* l_Lean_Elab_mkDeclName___rarg___closed__2;
 lean_object* l_Lean_Elab_mkDeclName___rarg___lambda__1___closed__3;
-lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_applyVisibility_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Name_append___main(lean_object*, lean_object*);
@@ -107,6 +106,7 @@ lean_object* l_Lean_Elab_elabModifiers___rarg___lambda__3___closed__3;
 lean_object* l_Lean_Elab_Modifiers_attrs___default;
 lean_object* l_Array_iterateMAux___main___at_Lean_Elab_expandDeclId___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_mkDeclName___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_elabModifiers_match__3(lean_object*);
 lean_object* l_Lean_throwErrorAt___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_mkDeclName_match__2___rarg(uint8_t, lean_object*, lean_object*);
@@ -1424,7 +1424,7 @@ lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean
 x_17 = l_List_append___rarg(x_16, x_15);
 x_18 = l_List_append___rarg(x_17, x_9);
 x_19 = l_Lean_List_format___rarg___closed__3;
-x_20 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_18, x_19);
+x_20 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_18, x_19);
 lean_dec(x_18);
 x_21 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_22 = lean_alloc_ctor(4, 2, 0);
@@ -1451,7 +1451,7 @@ x_29 = l_Lean_Elab_Modifiers_hasFormat___closed__7;
 x_30 = l_List_append___rarg(x_16, x_29);
 x_31 = l_List_append___rarg(x_30, x_9);
 x_32 = l_Lean_List_format___rarg___closed__3;
-x_33 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_31, x_32);
+x_33 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_31, x_32);
 lean_dec(x_31);
 x_34 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_35 = lean_alloc_ctor(4, 2, 0);
@@ -1484,7 +1484,7 @@ lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean
 x_45 = l_List_append___rarg(x_44, x_42);
 x_46 = l_List_append___rarg(x_45, x_9);
 x_47 = l_Lean_List_format___rarg___closed__3;
-x_48 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_46, x_47);
+x_48 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_46, x_47);
 lean_dec(x_46);
 x_49 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_50 = lean_alloc_ctor(4, 2, 0);
@@ -1511,7 +1511,7 @@ x_57 = l_Lean_Elab_Modifiers_hasFormat___closed__7;
 x_58 = l_List_append___rarg(x_44, x_57);
 x_59 = l_List_append___rarg(x_58, x_9);
 x_60 = l_Lean_List_format___rarg___closed__3;
-x_61 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_59, x_60);
+x_61 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_59, x_60);
 lean_dec(x_59);
 x_62 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_63 = lean_alloc_ctor(4, 2, 0);
@@ -1646,7 +1646,7 @@ lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean
 x_17 = l_List_append___rarg(x_16, x_15);
 x_18 = l_List_append___rarg(x_17, x_9);
 x_19 = l_Lean_List_format___rarg___closed__3;
-x_20 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_18, x_19);
+x_20 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_18, x_19);
 lean_dec(x_18);
 x_21 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_22 = lean_alloc_ctor(4, 2, 0);
@@ -1673,7 +1673,7 @@ x_29 = l_Lean_Elab_Modifiers_hasFormat___closed__7;
 x_30 = l_List_append___rarg(x_16, x_29);
 x_31 = l_List_append___rarg(x_30, x_9);
 x_32 = l_Lean_List_format___rarg___closed__3;
-x_33 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_31, x_32);
+x_33 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_31, x_32);
 lean_dec(x_31);
 x_34 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_35 = lean_alloc_ctor(4, 2, 0);
@@ -1706,7 +1706,7 @@ lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean
 x_45 = l_List_append___rarg(x_44, x_42);
 x_46 = l_List_append___rarg(x_45, x_9);
 x_47 = l_Lean_List_format___rarg___closed__3;
-x_48 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_46, x_47);
+x_48 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_46, x_47);
 lean_dec(x_46);
 x_49 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_50 = lean_alloc_ctor(4, 2, 0);
@@ -1733,7 +1733,7 @@ x_57 = l_Lean_Elab_Modifiers_hasFormat___closed__7;
 x_58 = l_List_append___rarg(x_44, x_57);
 x_59 = l_List_append___rarg(x_58, x_9);
 x_60 = l_Lean_List_format___rarg___closed__3;
-x_61 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_59, x_60);
+x_61 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_59, x_60);
 lean_dec(x_59);
 x_62 = l_Lean_Elab_Modifiers_hasFormat___closed__3;
 x_63 = lean_alloc_ctor(4, 2, 0);
diff --git a/stage0/stdlib/Lean/Elab/DeclUtil.c b/stage0/stdlib/Lean/Elab/DeclUtil.c
index a4e7e32f93..4b891a5409 100644
--- a/stage0/stdlib/Lean/Elab/DeclUtil.c
+++ b/stage0/stdlib/Lean/Elab/DeclUtil.c
@@ -24,7 +24,6 @@ lean_object* l_Lean_Meta_forallTelescopeCompatibleAux___rarg___lambda__4___boxed
 lean_object* l_Lean_Meta_forallTelescopeCompatibleAux___rarg___closed__1;
 lean_object* l_Lean_Meta_withLocalDecl___at_Lean_Meta_forallTelescopeCompatibleAux___spec__1(lean_object*);
 lean_object* l_Lean_Meta_forallTelescopeCompatibleAux_match__1(lean_object*);
-uint8_t l_Lean_Name_lt___main(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDecl___at_Lean_Meta_forallTelescopeCompatibleAux___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescopeCompatibleAux___rarg___lambda__4___closed__2;
 uint8_t lean_name_eq(lean_object*, lean_object*);
@@ -82,6 +81,7 @@ lean_object* l_Lean_Meta_forallTelescopeCompatibleAux___rarg___lambda__2___boxed
 uint8_t l_Lean_Elab_sortDeclLevelParams___lambda__1(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_BinderInfo_beq(uint8_t, uint8_t);
 extern lean_object* l_Lean_Meta_getMVarDecl___rarg___lambda__1___closed__3;
+uint8_t l_Lean_Name_lt(lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Lean_Elab_sortDeclLevelParams___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* lean_environment_main_module(lean_object*);
 uint8_t l_String_isPrefixOf(lean_object*, lean_object*);
@@ -1303,7 +1303,7 @@ else
 lean_object* x_9; lean_object* x_10; uint8_t x_11; 
 x_9 = l_Lean_Name_inhabited;
 x_10 = lean_array_get(x_9, x_3, x_5);
-x_11 = l_Lean_Name_lt___main(x_10, x_2);
+x_11 = l_Lean_Name_lt(x_10, x_2);
 lean_dec(x_10);
 if (x_11 == 0)
 {
@@ -1351,7 +1351,7 @@ lean_dec(x_14);
 x_37 = l_Lean_Name_inhabited;
 x_38 = lean_array_get(x_37, x_1, x_16);
 x_39 = lean_array_get(x_37, x_1, x_2);
-x_40 = l_Lean_Name_lt___main(x_38, x_39);
+x_40 = l_Lean_Name_lt(x_38, x_39);
 lean_dec(x_39);
 lean_dec(x_38);
 if (x_40 == 0)
@@ -1372,13 +1372,13 @@ lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21;
 x_18 = l_Lean_Name_inhabited;
 x_19 = lean_array_get(x_18, x_17, x_3);
 x_20 = lean_array_get(x_18, x_17, x_2);
-x_21 = l_Lean_Name_lt___main(x_19, x_20);
+x_21 = l_Lean_Name_lt(x_19, x_20);
 lean_dec(x_20);
 if (x_21 == 0)
 {
 lean_object* x_22; uint8_t x_23; 
 x_22 = lean_array_get(x_18, x_17, x_16);
-x_23 = l_Lean_Name_lt___main(x_22, x_19);
+x_23 = l_Lean_Name_lt(x_22, x_19);
 lean_dec(x_22);
 if (x_23 == 0)
 {
@@ -1411,7 +1411,7 @@ lean_dec(x_19);
 x_28 = lean_array_swap(x_17, x_2, x_3);
 x_29 = lean_array_get(x_18, x_28, x_16);
 x_30 = lean_array_get(x_18, x_28, x_3);
-x_31 = l_Lean_Name_lt___main(x_29, x_30);
+x_31 = l_Lean_Name_lt(x_29, x_30);
 lean_dec(x_29);
 if (x_31 == 0)
 {
diff --git a/stage0/stdlib/Lean/Elab/Do.c b/stage0/stdlib/Lean/Elab/Do.c
index 48f7c5db12..8218365c21 100644
--- a/stage0/stdlib/Lean/Elab/Do.c
+++ b/stage0/stdlib/Lean/Elab/Do.c
@@ -39,6 +39,7 @@ lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doLetArrowToCode___closed__2;
 extern lean_object* l_Lean_unitToExpr___lambda__1___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_declToTermCore___closed__4;
 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_Do_ToCodeBlock_doTryToCode___lambda__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult_match__1(lean_object*);
@@ -62,6 +63,7 @@ lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_declToTermCore___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doSeqToCode___closed__8;
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_Term_Do_hasBreakContinue___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_continueToTermCore___closed__13;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_returnToTermCore_match__1___rarg(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_mkFreshJP___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -103,7 +105,6 @@ lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_Do_ToCodeBlo
 lean_object* l_Lean_Elab_Term_Do_hasBreakContinue___boxed(lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_breakToTermCore___closed__19;
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_Term_Do_extendUpdatedVarsAux_update___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_withFor___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_mkPureUnitAction___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_Do_ToCodeBlock_doTryToCode___spec__2___closed__12;
@@ -250,6 +251,7 @@ lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_extractBind___lambda__1(
 lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult___closed__19;
 lean_object* l_Lean_throwErrorAt___at_Lean_Elab_Term_Do_ToCodeBlock_mkForInBody___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_Elab_Term_Do_mkAuxDeclFor___rarg___lambda__3___closed__5;
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_reassignToTermCore___closed__7;
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_Term_Do_mkReassignCore___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_declToTermCore___closed__8;
@@ -312,6 +314,7 @@ lean_object* l_Lean_Elab_Term_Do_CodeBlocl_toMessageData_loop___closed__17;
 extern lean_object* l_Lean_Elab_Term_expandFunBinders_loop___closed__11;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_breakToTermCore___closed__9;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doUnlessToCode(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_RBNode_fold___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doTryToCode___lambda__1(lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_hasLiftMethod___closed__1;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_checkReassignable_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -450,6 +453,7 @@ lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_withNewVars___rarg___boxed(lean_obj
 lean_object* l_Lean_Elab_Term_Do_pullExitPointsAux_match__1___rarg(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_Do_ToCodeBlock_doReassignArrowToCode___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_Elab_Term_expandFunBinders_loop___closed__7;
+lean_object* l_Std_RBNode_appendTrees___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doForToCode___closed__1;
 lean_object* l_Lean_Elab_Term_Do_mkAuxDeclFor___rarg___lambda__3___closed__7;
 extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Macros___hyg_464____closed__6;
@@ -468,7 +472,6 @@ lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult___closed__43;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_Do_concat___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_getLetPatDeclVars_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_ensureInsideFor___closed__2;
-extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
 lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_extractBind___closed__3;
 lean_object* l_Std_RBNode_balRight___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_convertTerminalActionIntoJmp_loop_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -521,7 +524,6 @@ extern lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__28;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_tryCatchPred___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_CheckAssignment_addAssignmentInfo___closed__4;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doForToCode___closed__11;
-uint8_t l_Std_RBNode_any___main___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_Do_ToCodeBlock_doIfToCode___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwErrorAt___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_CodeBlocl_toMessageData_loop_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -588,7 +590,6 @@ lean_object* l_Std_RBNode_balLeft___rarg(lean_object*, lean_object*, lean_object
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_ensureEOS___closed__2;
 lean_object* l___regBuiltin_Lean_Elab_Term_Do_elabDo(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Do_ToTerm_mkJoinPointCore___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_appendTrees___main___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_withNewVars___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Elab_App_0__Lean_Elab_Term_elabAppFn___closed__16;
 lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_ToCodeBlock_expandLiftMethodAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -625,6 +626,7 @@ lean_object* l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_pos
 lean_object* l_Lean_Elab_Term_Do_ToTerm_breakToTermCore___closed__18;
 lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_getDoLetArrowVars___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_Do_concat___spec__1___rarg(lean_object*);
 extern lean_object* l_Lean_myMacro____x40_Lean_Util_Trace___hyg_45____closed__13;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__32;
@@ -692,7 +694,6 @@ lean_object* l_Lean_Elab_Term_Do_mkAuxDeclFor___rarg___lambda__5___closed__7;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult___closed__18;
 lean_object* l___regBuiltin_Lean_Elab_Term_elabLiftMethod(lean_object*);
 extern lean_object* l_Lean_Elab_Term_expandFunBinders_loop___closed__12;
-lean_object* l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_mkJmp___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult___closed__5;
 lean_object* l_Lean_Elab_Term_Do_hasExitPointPred_loop___at_Lean_Elab_Term_Do_hasBreakContinue___spec__1___boxed(lean_object*);
@@ -727,7 +728,6 @@ lean_object* l_Lean_Elab_Term_Do_CodeBlocl_toMessageData_loop___closed__10;
 lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_mkIdBindFor___closed__2;
 extern lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__7;
 extern lean_object* l_Lean_Meta_getMVarDecl___rarg___lambda__1___closed__3;
-extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
 lean_object* l_Lean_Elab_Term_Do_getDoLetRecVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Elab_Term_Do_ToTerm_Kind_isRegular(uint8_t);
 lean_object* l_Lean_Elab_Term_Do_concat_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -799,6 +799,7 @@ lean_object* l_Lean_Elab_Term_Do_ToTerm_declToTermCore___closed__7;
 lean_object* l_Lean_Elab_Term_Do_mkAuxDeclFor___rarg___lambda__8(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_seqToTermCore___closed__7;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_Do_ToCodeBlock_doTryToCode___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Std_RBNode_any___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(lean_object*, lean_object*);
 extern lean_object* l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__2;
 lean_object* l_Lean_Elab_Term_elabLiftMethod___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_breakToTermCore___closed__4;
@@ -843,7 +844,6 @@ lean_object* l_Lean_Elab_Term_Do_mkAuxDeclFor___rarg___lambda__3___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doForToCode___closed__5;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult_match__1___rarg(uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Do_CodeBlocl_toMessageData_loop___spec__1(lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Elab_Term_Do_mkMatch(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_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_mkFreshJP___lambda__1___closed__1;
@@ -883,7 +883,6 @@ lean_object* l_Lean_throwError___at_Lean_Elab_Term_Do_mkJmp___spec__5___rarg(lea
 lean_object* l_Lean_Elab_Term_Do_mkFreshJP___lambda__1___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doReassignArrowToCode(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_mkOptionalNode___closed__1;
-lean_object* l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_actionTerminalToTermCore_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_getDoHaveVar(lean_object*);
 lean_object* l_Lean_Macro_expandMacro_x3fImp(lean_object*, lean_object*, lean_object*);
@@ -1014,6 +1013,7 @@ lean_object* l_Lean_Elab_Term_Do_getDoReassignVars___boxed(lean_object*, lean_ob
 lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_Do_ToCodeBlock_doTryToCode___spec__2___closed__4;
 lean_object* l_Lean_Core_mkFreshUserName___at_Lean_Elab_Term_Do_mkJmp___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_Do_ToCodeBlock_doTryToCode___lambda__4___closed__4;
+lean_object* l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_breakToTermCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_returnToTermCore_match__1(lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_Do_ToCodeBlock_doTryToCode___spec__1___closed__11;
@@ -1028,7 +1028,6 @@ lean_object* l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__26;
 lean_object* l_Lean_Elab_Term_Do_CodeBlocl_toMessageData_loop___closed__19;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_Do_ToCodeBlock_checkReassignable___spec__2___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doForToCode___closed__3;
-lean_object* l_Std_RBNode_any___main___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_mkAuxDeclFor___rarg___lambda__10(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_Do_getDoLetArrowVars___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__12;
@@ -1036,11 +1035,11 @@ lean_object* l_Lean_Elab_Term_Do_ToTerm_seqToTerm(lean_object*, lean_object*, le
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_Term_Do_hasBreakContinue___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_ReaderT_inhabited___rarg___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_mkTuple___spec__1___closed__2;
-lean_object* l_Std_RBNode_fold___main___at_Lean_registerTagAttribute___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_back___at_Lean_Syntax_Traverser_up___spec__2(lean_object*);
 lean_object* l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__11;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_continueToTermCore___closed__22;
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doLetArrowToCode_match__2(lean_object*);
+extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__11;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_actionTerminalToTermCore___closed__20;
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_Term_Do_ToCodeBlock_tryCatchPred___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_Do_ToCodeBlock_checkReassignable___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*);
@@ -1091,6 +1090,7 @@ lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_mkTuple(lean_object*,
 lean_object* l_Lean_Elab_Term_Do_ToCodeBlock_doReassignArrowToCode___closed__5;
 extern lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__1;
 lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_ToCodeBlock_expandLiftMethodAux_match__1(lean_object*);
+lean_object* l_Std_RBNode_any___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l___regBuiltin_Lean_Elab_Term_elabTypeOf___closed__2;
 lean_object* l_Array_iterateMAux___main___at_Lean_Elab_Term_Do_ToCodeBlock_doTryToCode___spec__2___closed__2;
 lean_object* l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult_match__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -2175,7 +2175,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_registerTagAttribute___spec__1(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_registerTagAttribute___spec__1(x_2, x_1);
 return x_3;
 }
 }
@@ -7063,158 +7063,160 @@ lean_dec(x_2);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
 {
-return x_2;
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
 }
 else
 {
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_2);
+if (x_4 == 0)
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = lean_ctor_get(x_2, 1);
-x_6 = lean_ctor_get(x_2, 2);
-x_7 = lean_ctor_get(x_2, 3);
-x_8 = l_Lean_Name_quickLt(x_1, x_5);
-if (x_8 == 0)
-{
-uint8_t x_9; 
-x_9 = l_Lean_Name_quickLt(x_5, x_1);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_ctor_get(x_2, 1);
+x_7 = lean_ctor_get(x_2, 2);
+x_8 = lean_ctor_get(x_2, 3);
+x_9 = l_Lean_Name_quickLt(x_1, x_6);
 if (x_9 == 0)
 {
-lean_object* x_10; 
+uint8_t x_10; 
+x_10 = l_Lean_Name_quickLt(x_6, x_1);
+if (x_10 == 0)
+{
+lean_object* x_11; 
 lean_free_object(x_2);
+lean_dec(x_7);
 lean_dec(x_6);
-lean_dec(x_5);
-x_10 = l_Std_RBNode_appendTrees___main___rarg(x_4, x_7);
-return x_10;
+x_11 = l_Std_RBNode_appendTrees___rarg(x_5, x_8);
+return x_11;
 }
 else
 {
-uint8_t x_11; 
-x_11 = l_Std_RBNode_isBlack___rarg(x_7);
-if (x_11 == 0)
+uint8_t x_12; 
+x_12 = l_Std_RBNode_isBlack___rarg(x_8);
+if (x_12 == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-x_12 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_7);
-x_13 = 0;
-lean_ctor_set(x_2, 3, x_12);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_13);
+lean_object* x_13; uint8_t x_14; 
+x_13 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_8);
+x_14 = 0;
+lean_ctor_set(x_2, 3, x_13);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_14);
 return x_2;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; 
+lean_object* x_15; lean_object* x_16; 
 lean_free_object(x_2);
-x_14 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_7);
-x_15 = l_Std_RBNode_balRight___rarg(x_4, x_5, x_6, x_14);
-return x_15;
+x_15 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_8);
+x_16 = l_Std_RBNode_balRight___rarg(x_5, x_6, x_7, x_15);
+return x_16;
 }
 }
 }
 else
 {
-uint8_t x_16; 
-x_16 = l_Std_RBNode_isBlack___rarg(x_4);
-if (x_16 == 0)
+uint8_t x_17; 
+x_17 = l_Std_RBNode_isBlack___rarg(x_5);
+if (x_17 == 0)
 {
-lean_object* x_17; uint8_t x_18; 
-x_17 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_4);
-x_18 = 0;
-lean_ctor_set(x_2, 0, x_17);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_18);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_5);
+x_19 = 0;
+lean_ctor_set(x_2, 0, x_18);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_19);
 return x_2;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; 
+lean_object* x_20; lean_object* x_21; 
 lean_free_object(x_2);
-x_19 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_4);
-x_20 = l_Std_RBNode_balLeft___rarg(x_19, x_5, x_6, x_7);
-return x_20;
+x_20 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_5);
+x_21 = l_Std_RBNode_balLeft___rarg(x_20, x_6, x_7, x_8);
+return x_21;
 }
 }
 }
 else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_21 = lean_ctor_get(x_2, 0);
-x_22 = lean_ctor_get(x_2, 1);
-x_23 = lean_ctor_get(x_2, 2);
-x_24 = lean_ctor_get(x_2, 3);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_22 = lean_ctor_get(x_2, 0);
+x_23 = lean_ctor_get(x_2, 1);
+x_24 = lean_ctor_get(x_2, 2);
+x_25 = lean_ctor_get(x_2, 3);
+lean_inc(x_25);
 lean_inc(x_24);
 lean_inc(x_23);
 lean_inc(x_22);
-lean_inc(x_21);
 lean_dec(x_2);
-x_25 = l_Lean_Name_quickLt(x_1, x_22);
-if (x_25 == 0)
-{
-uint8_t x_26; 
-x_26 = l_Lean_Name_quickLt(x_22, x_1);
+x_26 = l_Lean_Name_quickLt(x_1, x_23);
 if (x_26 == 0)
 {
-lean_object* x_27; 
+uint8_t x_27; 
+x_27 = l_Lean_Name_quickLt(x_23, x_1);
+if (x_27 == 0)
+{
+lean_object* x_28; 
+lean_dec(x_24);
 lean_dec(x_23);
-lean_dec(x_22);
-x_27 = l_Std_RBNode_appendTrees___main___rarg(x_21, x_24);
-return x_27;
+x_28 = l_Std_RBNode_appendTrees___rarg(x_22, x_25);
+return x_28;
 }
 else
 {
-uint8_t x_28; 
-x_28 = l_Std_RBNode_isBlack___rarg(x_24);
-if (x_28 == 0)
+uint8_t x_29; 
+x_29 = l_Std_RBNode_isBlack___rarg(x_25);
+if (x_29 == 0)
 {
-lean_object* x_29; uint8_t x_30; lean_object* x_31; 
-x_29 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_24);
-x_30 = 0;
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_21);
-lean_ctor_set(x_31, 1, x_22);
-lean_ctor_set(x_31, 2, x_23);
-lean_ctor_set(x_31, 3, x_29);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_30);
-return x_31;
+lean_object* x_30; uint8_t x_31; lean_object* x_32; 
+x_30 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_25);
+x_31 = 0;
+x_32 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_32, 0, x_22);
+lean_ctor_set(x_32, 1, x_23);
+lean_ctor_set(x_32, 2, x_24);
+lean_ctor_set(x_32, 3, x_30);
+lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31);
+return x_32;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_24);
-x_33 = l_Std_RBNode_balRight___rarg(x_21, x_22, x_23, x_32);
-return x_33;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_25);
+x_34 = l_Std_RBNode_balRight___rarg(x_22, x_23, x_24, x_33);
+return x_34;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = l_Std_RBNode_isBlack___rarg(x_21);
-if (x_34 == 0)
+uint8_t x_35; 
+x_35 = l_Std_RBNode_isBlack___rarg(x_22);
+if (x_35 == 0)
 {
-lean_object* x_35; uint8_t x_36; lean_object* x_37; 
-x_35 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_21);
-x_36 = 0;
-x_37 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_22);
-lean_ctor_set(x_37, 2, x_23);
-lean_ctor_set(x_37, 3, x_24);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
-return x_37;
+lean_object* x_36; uint8_t x_37; lean_object* x_38; 
+x_36 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_22);
+x_37 = 0;
+x_38 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_23);
+lean_ctor_set(x_38, 2, x_24);
+lean_ctor_set(x_38, 3, x_25);
+lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_37);
+return x_38;
 }
 else
 {
-lean_object* x_38; lean_object* x_39; 
-x_38 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_21);
-x_39 = l_Std_RBNode_balLeft___rarg(x_38, x_22, x_23, x_24);
-return x_39;
+lean_object* x_39; lean_object* x_40; 
+x_39 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_22);
+x_40 = l_Std_RBNode_balLeft___rarg(x_39, x_23, x_24, x_25);
+return x_40;
 }
 }
 }
@@ -7225,7 +7227,7 @@ lean_object* l_Std_RBNode_erase___at_Lean_Elab_Term_Do_eraseVars___spec__1(lean_
 _start:
 {
 lean_object* x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_2);
 x_4 = l_Std_RBNode_setBlack___rarg(x_3);
 return x_4;
 }
@@ -7266,11 +7268,11 @@ x_4 = l_Array_iterateMAux___main___at_Lean_Elab_Term_Do_eraseVars___spec__3(x_2,
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_del___main___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at_Lean_Elab_Term_Do_eraseVars___spec__2(x_1, x_2);
 lean_dec(x_1);
 return x_3;
 }
@@ -12656,7 +12658,7 @@ x_10 = l_Lean_Elab_Term_Do_extendUpdatedVarsAux_update(x_2, x_1, x_3, x_4, x_5,
 return x_10;
 }
 }
-uint8_t l_Std_RBNode_any___main___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(lean_object* x_1, lean_object* x_2) {
+uint8_t l_Std_RBNode_any___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -12682,7 +12684,7 @@ return x_9;
 else
 {
 uint8_t x_10; 
-x_10 = l_Std_RBNode_any___main___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(x_1, x_4);
+x_10 = l_Std_RBNode_any___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(x_1, x_4);
 if (x_10 == 0)
 {
 x_2 = x_6;
@@ -12702,7 +12704,7 @@ lean_object* l_Lean_Elab_Term_Do_extendUpdatedVars(lean_object* x_1, lean_object
 _start:
 {
 uint8_t x_10; 
-x_10 = l_Std_RBNode_any___main___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(x_1, x_2);
+x_10 = l_Std_RBNode_any___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(x_1, x_2);
 if (x_10 == 0)
 {
 uint8_t x_11; 
@@ -12869,18 +12871,18 @@ return x_40;
 }
 }
 }
-lean_object* l_Std_RBNode_any___main___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_any___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_any___main___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_any___at_Lean_Elab_Term_Do_extendUpdatedVars___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -12897,7 +12899,7 @@ lean_inc(x_4);
 x_5 = lean_ctor_get(x_2, 3);
 lean_inc(x_5);
 lean_dec(x_2);
-x_6 = l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_1, x_3);
+x_6 = l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_1, x_3);
 x_7 = lean_box(0);
 x_8 = l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(x_6, x_4, x_7);
 x_1 = x_8;
@@ -12910,7 +12912,7 @@ lean_object* l___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union(lean_object* x_
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_2, x_1);
 return x_3;
 }
 }
@@ -12922,7 +12924,7 @@ x_10 = lean_ctor_get(x_1, 1);
 lean_inc(x_10);
 x_11 = lean_ctor_get(x_2, 1);
 lean_inc(x_11);
-x_12 = l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_11, x_10);
+x_12 = l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_11, x_10);
 lean_inc(x_8);
 lean_inc(x_7);
 lean_inc(x_6);
@@ -13986,7 +13988,7 @@ lean_dec(x_7);
 x_9 = lean_ctor_get(x_8, 1);
 lean_inc(x_9);
 lean_dec(x_8);
-x_10 = l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_9, x_4);
+x_10 = l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_9, x_4);
 x_11 = lean_unsigned_to_nat(1u);
 x_12 = lean_nat_add(x_3, x_11);
 lean_dec(x_3);
@@ -15822,7 +15824,7 @@ x_15 = lean_array_set(x_14, x_7, x_13);
 x_16 = l_Lean_mkOptionalNode___closed__1;
 x_17 = lean_array_push(x_15, x_16);
 x_18 = lean_array_push(x_17, x_6);
-x_19 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
+x_19 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
 x_20 = l_Lean_mkAtomFrom(x_11, x_19);
 lean_dec(x_11);
 lean_inc(x_2);
@@ -15972,7 +15974,7 @@ lean_inc(x_16);
 x_17 = lean_ctor_get(x_15, 1);
 lean_inc(x_17);
 lean_dec(x_15);
-x_18 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
+x_18 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
 x_19 = l_Lean_mkAtomFrom(x_1, x_18);
 x_20 = l_Lean_mkOptionalNode___closed__2;
 x_21 = lean_array_push(x_20, x_16);
@@ -16799,7 +16801,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__20;
 x_3 = lean_unsigned_to_nat(809u);
 x_4 = lean_unsigned_to_nat(26u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -18406,7 +18408,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_continueToTermCore___closed__1;
 x_3 = lean_unsigned_to_nat(822u);
 x_4 = lean_unsigned_to_nat(26u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -18583,7 +18585,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_continueToTermCore___closed__1;
 x_3 = lean_unsigned_to_nat(826u);
 x_4 = lean_unsigned_to_nat(26u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -19784,7 +19786,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_breakToTermCore___closed__1;
 x_3 = lean_unsigned_to_nat(838u);
 x_4 = lean_unsigned_to_nat(26u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -19870,7 +19872,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_breakToTermCore___closed__1;
 x_3 = lean_unsigned_to_nat(842u);
 x_4 = lean_unsigned_to_nat(26u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -21149,7 +21151,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_actionTerminalToTermCore___closed__8;
 x_3 = lean_unsigned_to_nat(858u);
 x_4 = lean_unsigned_to_nat(26u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -25194,9 +25196,9 @@ _start:
 lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
 x_6 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__1;
 x_7 = l_Lean_mkAtomFrom(x_1, x_6);
-x_8 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
+x_8 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__11;
 x_9 = l_Lean_mkAtomFrom(x_1, x_8);
-x_10 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
+x_10 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
 x_11 = l_Lean_mkAtomFrom(x_1, x_10);
 x_12 = l_Lean_Elab_Term_Do_ToTerm_mkIte___closed__1;
 x_13 = lean_array_push(x_12, x_7);
@@ -26966,7 +26968,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_mkNestedKind___closed__1;
 x_3 = lean_unsigned_to_nat(1027u);
 x_4 = lean_unsigned_to_nat(25u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -27279,7 +27281,7 @@ x_1 = l_Lean_Elab_Term_Do_ToTerm_returnToTermCore___closed__19;
 x_2 = l_Lean_Elab_Term_Do_ToTerm_matchNestedTermResult___closed__3;
 x_3 = lean_unsigned_to_nat(1083u);
 x_4 = lean_unsigned_to_nat(25u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -37654,7 +37656,7 @@ lean_dec(x_7);
 x_9 = lean_ctor_get(x_8, 1);
 lean_inc(x_9);
 lean_dec(x_8);
-x_10 = l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_4, x_9);
+x_10 = l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_4, x_9);
 x_11 = lean_unsigned_to_nat(1u);
 x_12 = lean_nat_add(x_3, x_11);
 lean_dec(x_3);
@@ -37686,7 +37688,7 @@ lean_dec(x_3);
 x_8 = lean_ctor_get(x_7, 1);
 lean_inc(x_8);
 lean_dec(x_7);
-x_9 = l_Std_RBNode_fold___main___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_6, x_8);
+x_9 = l_Std_RBNode_fold___at___private_Lean_Elab_Do_0__Lean_Elab_Term_Do_union___spec__1(x_6, x_8);
 return x_9;
 }
 }
diff --git a/stage0/stdlib/Lean/Elab/Inductive.c b/stage0/stdlib/Lean/Elab/Inductive.c
index b689315530..b88363b180 100644
--- a/stage0/stdlib/Lean/Elab/Inductive.c
+++ b/stage0/stdlib/Lean/Elab/Inductive.c
@@ -107,7 +107,6 @@ lean_object* l_Lean_Elab_Command_accLevelAtCtor___closed__1;
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_checkValidInductiveModifier___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_applyAttributesAt(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getAppFn___main(lean_object*);
 lean_object* l_Lean_Elab_Command_ElabHeaderResult_inhabited;
 extern lean_object* l_String_splitAux___main___closed__1;
@@ -505,6 +504,7 @@ lean_object* l_Lean_Elab_Command_checkValidCtorModifier___lambda__2___closed__3;
 lean_object* l___private_Lean_Elab_Inductive_0__Lean_Elab_Command_collectUniversesFromCtorTypeAux_match__2(lean_object*);
 lean_object* l___private_Lean_Elab_Inductive_0__Lean_Elab_Command_collectUsed___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_checkLevelNames___spec__1___closed__2;
+uint8_t l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Inductive_0__Lean_Elab_Command_withInductiveLocalDecls_loop_match__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_isTypeImp___at_Lean_Meta_isType___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Inductive_0__Lean_Elab_Command_checkParamsAndResultType_match__2(lean_object*);
@@ -2028,7 +2028,7 @@ lean_dec(x_5);
 x_15 = lean_array_uget(x_2, x_4);
 x_16 = lean_ctor_get(x_15, 4);
 lean_inc(x_16);
-x_17 = l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(x_16, x_1);
+x_17 = l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(x_16, x_1);
 lean_dec(x_16);
 if (x_17 == 0)
 {
diff --git a/stage0/stdlib/Lean/Elab/LetRec.c b/stage0/stdlib/Lean/Elab/LetRec.c
index 911dcca075..f3218e3d2e 100644
--- a/stage0/stdlib/Lean/Elab/LetRec.c
+++ b/stage0/stdlib/Lean/Elab/LetRec.c
@@ -44,6 +44,7 @@ lean_object* l___private_Lean_Elab_LetRec_0__Lean_Elab_Term_mkLetRecDeclView_mat
 lean_object* l_Lean_Elab_Term_applyAttributesAt(lean_object*, lean_object*, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_LetRec_0__Lean_Elab_Term_mkLetRecDeclView___spec__7___lambda__1___closed__1;
 lean_object* l_Lean_Meta_instantiateMVars___at_Lean_Elab_Term_MVarErrorInfo_logError___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Expr_hasSyntheticSorry(lean_object*);
 lean_object* l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 lean_object* l_Lean_Elab_elabAttr___at___private_Lean_Elab_LetRec_0__Lean_Elab_Term_mkLetRecDeclView___spec__5___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -81,7 +82,6 @@ lean_object* l_Lean_Elab_elabAttr___at___private_Lean_Elab_LetRec_0__Lean_Elab_T
 lean_object* l___private_Lean_Elab_LetRec_0__Lean_Elab_Term_withAuxLocalDecls_loop___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_elabAttr___at___private_Lean_Elab_LetRec_0__Lean_Elab_Term_mkLetRecDeclView___spec__5___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkLambdaFVars___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabImplicitLambdaAux___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Expr_hasSyntheticSorry___main(lean_object*);
 lean_object* l_Lean_Syntax_getId(lean_object*);
 lean_object* l___private_Lean_Elab_LetRec_0__Lean_Elab_Term_withAuxLocalDecls_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
@@ -2089,7 +2089,7 @@ if (x_10 == 0)
 lean_object* x_11; lean_object* x_12; uint8_t x_13; 
 x_11 = lean_ctor_get(x_9, 0);
 x_12 = lean_ctor_get(x_9, 1);
-x_13 = l_Lean_Expr_hasSyntheticSorry___main(x_11);
+x_13 = l_Lean_Expr_hasSyntheticSorry(x_11);
 lean_dec(x_11);
 if (x_13 == 0)
 {
@@ -2114,7 +2114,7 @@ x_17 = lean_ctor_get(x_9, 1);
 lean_inc(x_17);
 lean_inc(x_16);
 lean_dec(x_9);
-x_18 = l_Lean_Expr_hasSyntheticSorry___main(x_16);
+x_18 = l_Lean_Expr_hasSyntheticSorry(x_16);
 lean_dec(x_16);
 if (x_18 == 0)
 {
diff --git a/stage0/stdlib/Lean/Elab/Match.c b/stage0/stdlib/Lean/Elab/Match.c
index 8714a183df..28a43cbea7 100644
--- a/stage0/stdlib/Lean/Elab/Match.c
+++ b/stage0/stdlib/Lean/Elab/Match.c
@@ -18,7 +18,6 @@ lean_object* l_List_reverse___rarg(lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_elabInaccessible___closed__2;
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processId_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabDiscrsWitMatchType_match__3(lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_withElaboratedLHS___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_elabNoMatch___closed__1;
@@ -31,6 +30,7 @@ lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_elabForall__
 lean_object* l_Lean_Elab_Term_PatternVar_hasToString_match__1(lean_object*);
 lean_object* l_Lean_Elab_Term_elabMatch_match__2(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_Meta_forallBoundedTelescope___at_Lean_Elab_Term_elabLetDeclAux___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*);
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___spec__2(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_CollectPatternVars_CtorApp_pushNewArg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -184,6 +184,7 @@ lean_object* l_Lean_Meta_mkFreshExprMVarWithIdImpl(lean_object*, lean_object*, u
 lean_object* l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_getNumExplicitCtorParams___spec__2(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_CollectPatternVars_collect___closed__13;
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___lambda__3___closed__1;
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_waitExpectedType_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -661,7 +662,6 @@ lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabAtomicDiscr_match
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_getNumExplicitCtorParams___spec__1(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___private_Lean_Elab_Match_0__Lean_Elab_Term_withElaboratedLHS___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_ToDepElimPattern_throwInvalidPattern___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Meta_kabstract_visit(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_elabMatchAltView_match__1(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*);
@@ -1432,7 +1432,7 @@ else
 lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; 
 lean_dec(x_36);
 lean_inc(x_18);
-x_45 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_18);
+x_45 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_18);
 x_46 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_46, 0, x_45);
 x_47 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabDiscrsWitMatchType___spec__1___lambda__1___closed__7;
@@ -1692,7 +1692,7 @@ else
 lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; 
 lean_dec(x_102);
 lean_inc(x_18);
-x_111 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_18);
+x_111 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_18);
 x_112 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_112, 0, x_111);
 x_113 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabDiscrsWitMatchType___spec__1___lambda__1___closed__7;
@@ -1820,7 +1820,7 @@ x_152 = lean_ctor_get(x_19, 1);
 lean_inc(x_152);
 lean_dec(x_19);
 x_153 = lean_array_get_size(x_4);
-x_154 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_153);
+x_154 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_153);
 x_155 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_155, 0, x_154);
 x_156 = l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabDiscrsWitMatchType___spec__1___lambda__1___closed__2;
@@ -5587,7 +5587,7 @@ x_1 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_CtorApp_p
 x_2 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_CtorApp_pushNewArg___closed__3;
 x_3 = lean_unsigned_to_nat(307u);
 x_4 = lean_unsigned_to_nat(17u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -18068,6 +18068,7 @@ if (x_5 == 0)
 {
 lean_object* x_6; 
 lean_dec(x_3);
+lean_dec(x_1);
 x_6 = lean_box(0);
 return x_6;
 }
@@ -18077,6 +18078,7 @@ lean_object* x_7; lean_object* x_8; uint8_t x_9;
 x_7 = lean_array_fget(x_2, x_3);
 x_8 = l_Lean_LocalDecl_type(x_7);
 lean_dec(x_7);
+lean_inc(x_1);
 x_9 = l_Lean_Expr_occurs(x_1, x_8);
 if (x_9 == 0)
 {
@@ -18090,6 +18092,7 @@ goto _start;
 else
 {
 lean_object* x_13; 
+lean_dec(x_1);
 x_13 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_13, 0, x_3);
 return x_13;
@@ -18174,7 +18177,6 @@ lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean
 x_35 = lean_ctor_get(x_32, 1);
 x_36 = lean_ctor_get(x_32, 2);
 x_37 = l_Array_findIdxAux___main___at___private_Lean_Elab_Match_0__Lean_Elab_Term_ToDepElimPattern_mkLocalDeclFor___spec__5(x_1, x_35, x_28);
-lean_dec(x_1);
 x_38 = lean_box(0);
 lean_inc(x_17);
 x_39 = l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(x_36, x_17, x_38);
@@ -18258,7 +18260,6 @@ lean_inc(x_58);
 lean_inc(x_57);
 lean_dec(x_32);
 x_60 = l_Array_findIdxAux___main___at___private_Lean_Elab_Match_0__Lean_Elab_Term_ToDepElimPattern_mkLocalDeclFor___spec__5(x_1, x_58, x_28);
-lean_dec(x_1);
 x_61 = lean_box(0);
 lean_inc(x_17);
 x_62 = l_Std_RBNode_insert___at_Lean_NameSet_insert___spec__1(x_59, x_17, x_61);
@@ -18472,7 +18473,6 @@ _start:
 lean_object* x_4; 
 x_4 = l_Array_findIdxAux___main___at___private_Lean_Elab_Match_0__Lean_Elab_Term_ToDepElimPattern_mkLocalDeclFor___spec__5(x_1, x_2, x_3);
 lean_dec(x_2);
-lean_dec(x_1);
 return x_4;
 }
 }
diff --git a/stage0/stdlib/Lean/Elab/MutualDef.c b/stage0/stdlib/Lean/Elab/MutualDef.c
index e57d3244fb..69c6f13efb 100644
--- a/stage0/stdlib/Lean/Elab/MutualDef.c
+++ b/stage0/stdlib/Lean/Elab/MutualDef.c
@@ -26,7 +26,6 @@ size_t l_USize_add(size_t, size_t);
 lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Elab_Term_elabLetDeclAux___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*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getAllUserLevelNames(lean_object*);
 lean_object* l_Lean_Elab_Term_MutualClosure_FixPoint_run_match__1(lean_object*);
-extern lean_object* l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1;
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -51,6 +50,7 @@ lean_object* l_Lean_Syntax_getOptional_x3f(lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabFunValues___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
+lean_object* l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkModifiers___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -94,6 +94,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkL
 uint8_t l_Lean_checkTraceOption(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_elabModifiers___rarg___closed__2;
 lean_object* l_Array_umapMAux___main___at_Lean_LocalContext_getFVars___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_registerFailedToInferDefTypeInfo___closed__3;
@@ -105,6 +106,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__7
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__2___closed__1;
 lean_object* l_Array_reverseAux___main___rarg(lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_NameSet_Lean_Data_Name___instance__7;
 lean_object* l_Lean_Elab_checkNotAlreadyDeclared___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__4___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__3___closed__3;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___closed__2;
@@ -127,7 +129,6 @@ lean_object* l_Lean_Elab_Term_applyAttributesAt(lean_object*, lean_object*, uint
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__2___rarg(lean_object*);
 lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkKinds___lambda__1(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkInitialUsedFVarsMap___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_lambdaTelescope___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosureFor___spec__3(lean_object*);
 lean_object* l_Lean_Elab_Term_MutualClosure_ClosureState_newLocalDecls___default;
@@ -139,7 +140,9 @@ lean_object* l_Lean_Elab_Term_MutualClosure_main(lean_object*, lean_object*, lea
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_preprocess___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_foldAux___main___at_Lean_Elab_Term_MutualClosure_insertReplacementForMainFns___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_expandDeclId___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___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_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_indexOfAux___main___at_Lean_LocalContext_erase___spec__3(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -152,6 +155,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkC
 lean_object* l_List_foldl___main___at_Lean_Elab_Term_MutualClosure_pushLetRecs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_LocalContext_contains(lean_object*, lean_object*);
 uint8_t l_Lean_Elab_DefKind_isExample(uint8_t);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_MutualClosure_insertReplacementForMainFns___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkLetRecsToLiftTypes(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -175,7 +179,6 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_Fix
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureFor___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkLetRecsToLiftTypes___spec__1___closed__2;
 lean_object* l_List_forM___main___at_Lean_Elab_Term_MutualClosure_main___spec__3___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_withFunLocalDecls(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName___closed__2;
@@ -187,6 +190,7 @@ uint8_t l_List_foldr___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___closed__1;
 lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_isTheorem___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_expandDeclId___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__1___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*);
+extern lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___closed__2;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName___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_MutualDef_0__Lean_Elab_Term_withFunLocalDecls_loop(lean_object*);
@@ -223,10 +227,8 @@ lean_object* l_Lean_Elab_Term_registerCustomErrorIfMVar(lean_object*, lean_objec
 lean_object* l_Lean_Elab_elabModifiers___at_Lean_Elab_Command_elabMutualDef___spec__1___lambda__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_MutualClosure_getModifiersForLetRecs(lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_elabAttr___at_Lean_Elab_Command_elabMutualDef___spec__4___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_MutualClosure_pushLetRecs(lean_object*, lean_object*, uint8_t, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__4___closed__2;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf_match__2(lean_object*);
 lean_object* l_Lean_Elab_Term_elabMutualDef(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -241,7 +243,6 @@ lean_object* l_List_mapM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_
 lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM___main___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__2___closed__1;
 lean_object* l_Lean_Elab_Term_MutualClosure_pushLetRecs___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkModifiers___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkLetRecsToLiftTypes___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_collectMVars(lean_object*, lean_object*);
 lean_object* l_List_mapM___main___at_Lean_Elab_Term_MutualClosure_main___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -251,6 +252,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___box
 lean_object* l_Lean_Elab_elabModifiers___at_Lean_Elab_Command_elabMutualDef___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_replaceRef(lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
+uint8_t l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Util_0__Lean_Elab_expandMacro_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Lean_Elab_Term_MutualClosure_insertReplacementForLetRecs___spec__1(lean_object*, lean_object*);
@@ -262,11 +264,9 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName_match_
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkInitialUsedFVarsMap___spec__3(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_withUsedWhen___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_throwAlreadyDeclaredUniverseLevel___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosureFor___spec__2(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Elab_Term_elabLetDeclAux___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_Command_mkDefViewOfConstant___closed__8;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_instantiateMVarsAtHeader___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -281,6 +281,10 @@ lean_object* l_Lean_Meta_mkLambdaFVars___at___private_Lean_Elab_Term_0__Lean_Ela
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_declValToTerm___closed__2;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___closed__6;
+lean_object* l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_declValToTerm___closed__1;
 extern lean_object* l_Lean_Elab_elabModifiers___rarg___lambda__3___closed__2;
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
@@ -297,6 +301,7 @@ extern lean_object* l_Lean_Elab_elabModifiers___rarg___lambda__3___closed__4;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___closed__3;
 lean_object* l_Lean_Elab_elabAttr___at_Lean_Elab_Command_elabMutualDef___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_preprocess(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwErrorAt___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_fixpoint___spec__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -310,7 +315,6 @@ uint8_t l_Lean_Name_isAtomic(lean_object*);
 lean_object* l_Lean_Elab_elabAttr___at_Lean_Elab_Command_elabMutualDef___spec__4___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Environment_contains(lean_object*, lean_object*);
 extern lean_object* l_Lean_protectedExt;
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_withFunLocalDecls___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_fixpoint_match__1(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check_match__1(lean_object*);
@@ -330,6 +334,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_Fix
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureFor_match__1(lean_object*);
 lean_object* l_List_redLength___main___rarg(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__2___closed__3;
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(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_Elab_checkNotAlreadyDeclared___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -369,7 +374,6 @@ lean_object* l_Lean_Meta_instantiateForall___at___private_Lean_Elab_MutualDef_0_
 lean_object* l_List_mapM___main___at_Lean_Elab_Term_elabMutualDef___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Command_elabMutualDef___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_fixpoint___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_MutualClosure_main___spec__8(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Term_MutualClosure_main___spec__8___boxed(lean_object*, lean_object*, lean_object*);
@@ -386,7 +390,6 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__2
 lean_object* l_Lean_Elab_addPreDefinitions(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_resetMessageLog(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_contains___at___private_Lean_Class_1__checkOutParam___main___spec__1(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun_match__1___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_FindImpl_initCache;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosureFor___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*);
@@ -398,7 +401,6 @@ lean_object* l_Std_PersistentArray_push___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureFor(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Macro_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_LocalDecl_index(lean_object*);
 lean_object* l_Lean_Syntax_getSepArgs(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_removeUnusedVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -417,6 +419,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkLetRecsToLif
 lean_object* l_Lean_Elab_throwAlreadyDeclaredUniverseLevel___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_collectUsed___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___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_removeUnusedVars___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_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_withFunLocalDecls_loop___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_isExample___boxed(lean_object*);
 lean_object* l_Lean_mkPrivateName(lean_object*, lean_object*);
@@ -437,7 +440,6 @@ lean_object* lean_panic_fn(lean_object*, lean_object*);
 extern lean_object* l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
 lean_object* l_Lean_Meta_withLocalDecl___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabImplicitLambda___spec__1___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkInitialUsedFVarsMap___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_NameSet_Inhabited;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__5___closed__3;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux_match__2(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_withUsedWhen___rarg(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -464,7 +466,9 @@ extern lean_object* l_Lean_Elab_throwAlreadyDeclaredUniverseLevel___rarg___close
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_Term_MutualClosure_getModifiersForLetRecs___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_registerFailedToInferDefTypeInfo___closed__1;
 lean_object* l_Lean_Elab_Command_getRef(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_mapM___main___at_Lean_Elab_Term_MutualClosure_main___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_registerFailedToInferDefTypeInfo___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_MutualClosure_ClosureState_newLetDecls___default;
 lean_object* l_Lean_Elab_Term_elabType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -478,7 +482,6 @@ lean_object* l_List_forInAux___main___at___private_Lean_Elab_MutualDef_0__Lean_E
 lean_object* lean_expr_update_lambda(lean_object*, uint8_t, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_Match_Pattern_toMessageData___closed__6;
 lean_object* l_Lean_Meta_getZetaFVarIds___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(lean_object*, lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_isModified___rarg(lean_object*);
 uint8_t l_Lean_Syntax_isNone(lean_object*);
 lean_object* l_Lean_setEnv___at_Lean_Elab_Term_declareTacticSyntax___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -486,15 +489,15 @@ lean_object* l_Lean_Elab_Term_MutualClosure_Replacement_apply_match__2(lean_obje
 lean_object* l_List_foldr___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_erase___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_elabAttrs___at_Lean_Elab_Command_elabMutualDef___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getZetaFVarIds___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___spec__3___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toList___rarg(lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_Inhabited;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_modifyUsedFVars___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_elabModifiers___rarg___lambda__3___closed__7;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__3___closed__1;
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_collectUsed___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_elabDeclAttrs___at_Lean_Elab_Command_elabMutualDef___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -513,6 +516,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_instantiateMVarsA
 lean_object* l_Lean_Elab_instantiateMVarsAtPreDecls(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders_match__1(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_fixpoint(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName_match__2(lean_object*);
@@ -532,7 +536,6 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_Fix
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___main___at_Lean_MessageData_hasCoeOfListExpr___spec__1(lean_object*);
 lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_resetZetaFVarIds___at_Lean_Elab_Term_MutualClosure_main___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
@@ -545,7 +548,6 @@ uint8_t l_Lean_Elab_isFreshInstanceName(lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkModifiers___closed__3;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_removeUnusedVars_match__1(lean_object*);
 lean_object* l_Lean_Elab_fixLevelParams(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_update_app(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_isTheorem___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -555,12 +557,9 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_check___lambda__5
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkInitialUsedFVarsMap___spec__2(lean_object*, lean_object*, size_t, size_t, lean_object*);
 lean_object* l_Lean_Elab_mkDeclName___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___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_addTrace___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkClosureForAux___spec__6(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_662____closed__2;
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkModifiers(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Term_throwErrorIfErrors___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkKinds___lambda__1___closed__1;
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 lean_object* l_List_forM___main___at_Lean_Elab_Term_MutualClosure_main___spec__3___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -584,6 +583,7 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_Fix
 lean_object* l_List_findSome_x3f___main___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName_match__1(lean_object*);
 lean_object* l_Lean_Elab_Term_MutualClosure_FixPoint_run(lean_object*, lean_object*);
+uint8_t l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_markModified___boxed(lean_object*);
 lean_object* l_Lean_Elab_applyVisibility___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_elabHeaders___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_checkNotAlreadyDeclared___rarg___lambda__1___closed__2;
@@ -1348,7 +1348,7 @@ x_16 = lean_array_fget(x_1, x_12);
 x_17 = lean_ctor_get(x_2, 4);
 x_18 = lean_ctor_get(x_16, 4);
 lean_inc(x_18);
-x_19 = l_List_beq___main___at_Lean_OpenDecl_HasToString___spec__1(x_17, x_18);
+x_19 = l_List_beq___main___at_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___spec__1(x_17, x_18);
 lean_dec(x_18);
 if (x_19 == 0)
 {
@@ -5391,574 +5391,104 @@ return x_9;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(lean_object* x_1, lean_object* x_2, size_t x_3, lean_object* x_4, lean_object* x_5) {
+uint8_t l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-uint8_t x_6; lean_object* x_7; size_t x_107; size_t x_108; lean_object* x_109; size_t x_110; uint8_t x_111; 
-x_107 = lean_ptr_addr(x_4);
-x_108 = x_3 == 0 ? 0 : x_107 % x_3;
-x_109 = lean_array_uget(x_5, x_108);
-x_110 = lean_ptr_addr(x_109);
-lean_dec(x_109);
-x_111 = x_110 == x_107;
-if (x_111 == 0)
+if (lean_obj_tag(x_3) == 1)
 {
-lean_object* x_112; uint8_t x_113; 
-lean_inc(x_4);
-x_112 = lean_array_uset(x_5, x_108, x_4);
-x_113 = 0;
-x_6 = x_113;
-x_7 = x_112;
-goto block_106;
+lean_object* x_4; uint8_t x_5; 
+x_4 = lean_ctor_get(x_3, 0);
+x_5 = l_Array_contains___at_Lean_Meta_addInstanceEntry___spec__11(x_1, x_3);
+if (x_5 == 0)
+{
+uint8_t x_6; uint8_t x_7; 
+x_6 = 0;
+x_7 = l_List_foldr___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__1(x_4, x_6, x_2);
+return x_7;
 }
 else
 {
-uint8_t x_114; 
-x_114 = 1;
-x_6 = x_114;
-x_7 = x_5;
-goto block_106;
-}
-block_106:
-{
-lean_object* x_8; 
-if (x_6 == 0)
-{
-if (lean_obj_tag(x_4) == 1)
-{
-lean_object* x_94; uint8_t x_95; 
-x_94 = lean_ctor_get(x_4, 0);
-lean_inc(x_94);
-x_95 = l_Array_contains___at_Lean_Meta_addInstanceEntry___spec__11(x_1, x_4);
-if (x_95 == 0)
-{
-uint8_t x_96; uint8_t x_97; 
-x_96 = 0;
-x_97 = l_List_foldr___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__1(x_94, x_96, x_2);
-lean_dec(x_94);
-if (x_97 == 0)
-{
-lean_object* x_98; 
-x_98 = lean_box(0);
-x_8 = x_98;
-goto block_93;
-}
-else
-{
-lean_object* x_99; lean_object* x_100; 
-x_99 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_99, 0, x_4);
-x_100 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_100, 0, x_99);
-lean_ctor_set(x_100, 1, x_7);
-return x_100;
+uint8_t x_8; 
+x_8 = 1;
+return x_8;
 }
 }
 else
 {
-lean_object* x_101; lean_object* x_102; 
-lean_dec(x_94);
-x_101 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_101, 0, x_4);
-x_102 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_102, 0, x_101);
-lean_ctor_set(x_102, 1, x_7);
-return x_102;
-}
-}
-else
-{
-lean_object* x_103; 
-x_103 = lean_box(0);
-x_8 = x_103;
-goto block_93;
-}
-}
-else
-{
-lean_object* x_104; lean_object* x_105; 
-lean_dec(x_4);
-x_104 = lean_box(0);
-x_105 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_105, 0, x_104);
-lean_ctor_set(x_105, 1, x_7);
-return x_105;
-}
-block_93:
-{
-lean_dec(x_8);
-switch (lean_obj_tag(x_4)) {
-case 5:
-{
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_9 = lean_ctor_get(x_4, 0);
-lean_inc(x_9);
-x_10 = lean_ctor_get(x_4, 1);
-lean_inc(x_10);
-lean_dec(x_4);
-x_11 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(x_1, x_2, x_3, x_9, x_7);
-x_12 = lean_ctor_get(x_11, 0);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
-{
-lean_object* x_13; 
-x_13 = lean_ctor_get(x_11, 1);
-lean_inc(x_13);
-lean_dec(x_11);
-x_4 = x_10;
-x_5 = x_13;
-goto _start;
-}
-else
-{
-uint8_t x_15; 
-lean_dec(x_10);
-x_15 = !lean_is_exclusive(x_11);
-if (x_15 == 0)
-{
-lean_object* x_16; uint8_t x_17; 
-x_16 = lean_ctor_get(x_11, 0);
-lean_dec(x_16);
-x_17 = !lean_is_exclusive(x_12);
-if (x_17 == 0)
-{
-return x_11;
-}
-else
-{
-lean_object* x_18; lean_object* x_19; 
-x_18 = lean_ctor_get(x_12, 0);
-lean_inc(x_18);
-lean_dec(x_12);
-x_19 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_19, 0, x_18);
-lean_ctor_set(x_11, 0, x_19);
-return x_11;
-}
-}
-else
-{
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_20 = lean_ctor_get(x_11, 1);
-lean_inc(x_20);
-lean_dec(x_11);
-x_21 = lean_ctor_get(x_12, 0);
-lean_inc(x_21);
-if (lean_is_exclusive(x_12)) {
- lean_ctor_release(x_12, 0);
- x_22 = x_12;
-} else {
- lean_dec_ref(x_12);
- x_22 = lean_box(0);
-}
-if (lean_is_scalar(x_22)) {
- x_23 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_23 = x_22;
-}
-lean_ctor_set(x_23, 0, x_21);
-x_24 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_24, 0, x_23);
-lean_ctor_set(x_24, 1, x_20);
-return x_24;
-}
-}
-}
-case 6:
-{
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_25 = lean_ctor_get(x_4, 1);
-lean_inc(x_25);
-x_26 = lean_ctor_get(x_4, 2);
-lean_inc(x_26);
-lean_dec(x_4);
-x_27 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(x_1, x_2, x_3, x_25, x_7);
-x_28 = lean_ctor_get(x_27, 0);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
-{
-lean_object* x_29; 
-x_29 = lean_ctor_get(x_27, 1);
-lean_inc(x_29);
-lean_dec(x_27);
-x_4 = x_26;
-x_5 = x_29;
-goto _start;
-}
-else
-{
-uint8_t x_31; 
-lean_dec(x_26);
-x_31 = !lean_is_exclusive(x_27);
-if (x_31 == 0)
-{
-lean_object* x_32; uint8_t x_33; 
-x_32 = lean_ctor_get(x_27, 0);
-lean_dec(x_32);
-x_33 = !lean_is_exclusive(x_28);
-if (x_33 == 0)
-{
-return x_27;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = lean_ctor_get(x_28, 0);
-lean_inc(x_34);
-lean_dec(x_28);
-x_35 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_27, 0, x_35);
-return x_27;
-}
-}
-else
-{
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-x_36 = lean_ctor_get(x_27, 1);
-lean_inc(x_36);
-lean_dec(x_27);
-x_37 = lean_ctor_get(x_28, 0);
-lean_inc(x_37);
-if (lean_is_exclusive(x_28)) {
- lean_ctor_release(x_28, 0);
- x_38 = x_28;
-} else {
- lean_dec_ref(x_28);
- x_38 = lean_box(0);
-}
-if (lean_is_scalar(x_38)) {
- x_39 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_39 = x_38;
-}
-lean_ctor_set(x_39, 0, x_37);
-x_40 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_40, 0, x_39);
-lean_ctor_set(x_40, 1, x_36);
-return x_40;
-}
-}
-}
-case 7:
-{
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_41 = lean_ctor_get(x_4, 1);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_4, 2);
-lean_inc(x_42);
-lean_dec(x_4);
-x_43 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(x_1, x_2, x_3, x_41, x_7);
-x_44 = lean_ctor_get(x_43, 0);
-lean_inc(x_44);
-if (lean_obj_tag(x_44) == 0)
-{
-lean_object* x_45; 
-x_45 = lean_ctor_get(x_43, 1);
-lean_inc(x_45);
-lean_dec(x_43);
-x_4 = x_42;
-x_5 = x_45;
-goto _start;
-}
-else
-{
-uint8_t x_47; 
-lean_dec(x_42);
-x_47 = !lean_is_exclusive(x_43);
-if (x_47 == 0)
-{
-lean_object* x_48; uint8_t x_49; 
-x_48 = lean_ctor_get(x_43, 0);
-lean_dec(x_48);
-x_49 = !lean_is_exclusive(x_44);
-if (x_49 == 0)
-{
-return x_43;
-}
-else
-{
-lean_object* x_50; lean_object* x_51; 
-x_50 = lean_ctor_get(x_44, 0);
-lean_inc(x_50);
-lean_dec(x_44);
-x_51 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_51, 0, x_50);
-lean_ctor_set(x_43, 0, x_51);
-return x_43;
-}
-}
-else
-{
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_52 = lean_ctor_get(x_43, 1);
-lean_inc(x_52);
-lean_dec(x_43);
-x_53 = lean_ctor_get(x_44, 0);
-lean_inc(x_53);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- x_54 = x_44;
-} else {
- lean_dec_ref(x_44);
- x_54 = lean_box(0);
-}
-if (lean_is_scalar(x_54)) {
- x_55 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_55 = x_54;
-}
-lean_ctor_set(x_55, 0, x_53);
-x_56 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_56, 0, x_55);
-lean_ctor_set(x_56, 1, x_52);
-return x_56;
-}
-}
-}
-case 8:
-{
-lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_57 = lean_ctor_get(x_4, 1);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_4, 2);
-lean_inc(x_58);
-x_59 = lean_ctor_get(x_4, 3);
-lean_inc(x_59);
-lean_dec(x_4);
-x_60 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(x_1, x_2, x_3, x_57, x_7);
-x_61 = lean_ctor_get(x_60, 0);
-lean_inc(x_61);
-if (lean_obj_tag(x_61) == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_62 = lean_ctor_get(x_60, 1);
-lean_inc(x_62);
-lean_dec(x_60);
-x_63 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(x_1, x_2, x_3, x_58, x_62);
-x_64 = lean_ctor_get(x_63, 0);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; 
-x_65 = lean_ctor_get(x_63, 1);
-lean_inc(x_65);
-lean_dec(x_63);
-x_4 = x_59;
-x_5 = x_65;
-goto _start;
-}
-else
-{
-uint8_t x_67; 
-lean_dec(x_59);
-x_67 = !lean_is_exclusive(x_63);
-if (x_67 == 0)
-{
-lean_object* x_68; uint8_t x_69; 
-x_68 = lean_ctor_get(x_63, 0);
-lean_dec(x_68);
-x_69 = !lean_is_exclusive(x_64);
-if (x_69 == 0)
-{
-return x_63;
-}
-else
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = lean_ctor_get(x_64, 0);
-lean_inc(x_70);
-lean_dec(x_64);
-x_71 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_63, 0, x_71);
-return x_63;
-}
-}
-else
-{
-lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; 
-x_72 = lean_ctor_get(x_63, 1);
-lean_inc(x_72);
-lean_dec(x_63);
-x_73 = lean_ctor_get(x_64, 0);
-lean_inc(x_73);
-if (lean_is_exclusive(x_64)) {
- lean_ctor_release(x_64, 0);
- x_74 = x_64;
-} else {
- lean_dec_ref(x_64);
- x_74 = lean_box(0);
-}
-if (lean_is_scalar(x_74)) {
- x_75 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_75 = x_74;
-}
-lean_ctor_set(x_75, 0, x_73);
-x_76 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_76, 0, x_75);
-lean_ctor_set(x_76, 1, x_72);
-return x_76;
-}
-}
-}
-else
-{
-uint8_t x_77; 
-lean_dec(x_59);
-lean_dec(x_58);
-x_77 = !lean_is_exclusive(x_60);
-if (x_77 == 0)
-{
-lean_object* x_78; uint8_t x_79; 
-x_78 = lean_ctor_get(x_60, 0);
-lean_dec(x_78);
-x_79 = !lean_is_exclusive(x_61);
-if (x_79 == 0)
-{
-return x_60;
-}
-else
-{
-lean_object* x_80; lean_object* x_81; 
-x_80 = lean_ctor_get(x_61, 0);
-lean_inc(x_80);
-lean_dec(x_61);
-x_81 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_81, 0, x_80);
-lean_ctor_set(x_60, 0, x_81);
-return x_60;
-}
-}
-else
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-x_82 = lean_ctor_get(x_60, 1);
-lean_inc(x_82);
-lean_dec(x_60);
-x_83 = lean_ctor_get(x_61, 0);
-lean_inc(x_83);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- x_84 = x_61;
-} else {
- lean_dec_ref(x_61);
- x_84 = lean_box(0);
-}
-if (lean_is_scalar(x_84)) {
- x_85 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_85 = x_84;
-}
-lean_ctor_set(x_85, 0, x_83);
-x_86 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_86, 0, x_85);
-lean_ctor_set(x_86, 1, x_82);
-return x_86;
-}
-}
-}
-case 10:
-{
-lean_object* x_87; 
-x_87 = lean_ctor_get(x_4, 1);
-lean_inc(x_87);
-lean_dec(x_4);
-x_4 = x_87;
-x_5 = x_7;
-goto _start;
-}
-case 11:
-{
-lean_object* x_89; 
-x_89 = lean_ctor_get(x_4, 2);
-lean_inc(x_89);
-lean_dec(x_4);
-x_4 = x_89;
-x_5 = x_7;
-goto _start;
-}
-default: 
-{
-lean_object* x_91; lean_object* x_92; 
-lean_dec(x_4);
-x_91 = lean_box(0);
-x_92 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_92, 0, x_91);
-lean_ctor_set(x_92, 1, x_7);
-return x_92;
-}
-}
-}
+uint8_t x_9; 
+x_9 = 0;
+return x_9;
 }
 }
 }
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-size_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
-x_4 = 8192;
-x_5 = l_Lean_Expr_FindImpl_initCache;
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(x_2, x_3, x_4, x_1, x_5);
-x_7 = lean_ctor_get(x_6, 0);
-lean_inc(x_7);
-lean_dec(x_6);
-if (lean_obj_tag(x_7) == 0)
+lean_object* x_4; size_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+x_4 = lean_alloc_closure((void*)(l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___lambda__1___boxed), 3, 2);
+lean_closure_set(x_4, 0, x_2);
+lean_closure_set(x_4, 1, x_3);
+x_5 = 8192;
+x_6 = l_Lean_Expr_FindImpl_initCache;
+x_7 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_4, x_5, x_1, x_6);
+x_8 = lean_ctor_get(x_7, 0);
+lean_inc(x_8);
+lean_dec(x_7);
+if (lean_obj_tag(x_8) == 0)
 {
-lean_object* x_8; 
-x_8 = lean_box(0);
+lean_object* x_9; 
+x_9 = lean_box(0);
+return x_9;
+}
+else
+{
+uint8_t x_10; 
+x_10 = !lean_is_exclusive(x_8);
+if (x_10 == 0)
+{
+lean_object* x_11; 
+x_11 = lean_ctor_get(x_8, 0);
+if (lean_obj_tag(x_11) == 1)
+{
+lean_object* x_12; 
+x_12 = lean_ctor_get(x_11, 0);
+lean_inc(x_12);
+lean_dec(x_11);
+lean_ctor_set(x_8, 0, x_12);
 return x_8;
 }
 else
 {
-uint8_t x_9; 
-x_9 = !lean_is_exclusive(x_7);
-if (x_9 == 0)
-{
-lean_object* x_10; 
-x_10 = lean_ctor_get(x_7, 0);
-if (lean_obj_tag(x_10) == 1)
-{
-lean_object* x_11; 
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-lean_dec(x_10);
-lean_ctor_set(x_7, 0, x_11);
-return x_7;
-}
-else
-{
-lean_object* x_12; 
-lean_free_object(x_7);
-lean_dec(x_10);
-x_12 = lean_box(0);
-return x_12;
-}
-}
-else
-{
 lean_object* x_13; 
-x_13 = lean_ctor_get(x_7, 0);
-lean_inc(x_13);
-lean_dec(x_7);
-if (lean_obj_tag(x_13) == 1)
-{
-lean_object* x_14; lean_object* x_15; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-lean_dec(x_13);
-x_15 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_15, 0, x_14);
-return x_15;
+lean_free_object(x_8);
+lean_dec(x_11);
+x_13 = lean_box(0);
+return x_13;
+}
 }
 else
 {
-lean_object* x_16; 
-lean_dec(x_13);
-x_16 = lean_box(0);
+lean_object* x_14; 
+x_14 = lean_ctor_get(x_8, 0);
+lean_inc(x_14);
+lean_dec(x_8);
+if (lean_obj_tag(x_14) == 1)
+{
+lean_object* x_15; lean_object* x_16; 
+x_15 = lean_ctor_get(x_14, 0);
+lean_inc(x_15);
+lean_dec(x_14);
+x_16 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_16, 0, x_15);
 return x_16;
 }
+else
+{
+lean_object* x_17; 
+lean_dec(x_14);
+x_17 = lean_box(0);
+return x_17;
+}
 }
 }
 }
@@ -5976,26 +5506,16 @@ x_6 = lean_box(x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-size_t x_6; lean_object* x_7; 
-x_6 = lean_unbox_usize(x_3);
+uint8_t x_4; lean_object* x_5; 
+x_4 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___lambda__1(x_1, x_2, x_3);
 lean_dec(x_3);
-x_7 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___spec__2(x_1, x_2, x_6, x_4, x_5);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_7;
-}
-}
-lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun(x_1, x_2, x_3);
-lean_dec(x_3);
-lean_dec(x_2);
-return x_4;
+x_5 = lean_box(x_4);
+return x_5;
 }
 }
 lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_getFunName_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -6350,6 +5870,7 @@ lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_2);
+lean_dec(x_1);
 x_11 = lean_box(0);
 x_12 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_12, 0, x_11);
@@ -6366,6 +5887,8 @@ lean_inc(x_14);
 lean_dec(x_3);
 x_15 = lean_ctor_get(x_13, 7);
 lean_inc(x_15);
+lean_inc(x_2);
+lean_inc(x_1);
 x_16 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_typeHasRecFun(x_15, x_1, x_2);
 if (lean_obj_tag(x_16) == 0)
 {
@@ -6377,6 +5900,7 @@ else
 {
 lean_object* x_18; lean_object* x_19; 
 lean_dec(x_14);
+lean_dec(x_1);
 x_18 = lean_ctor_get(x_16, 0);
 lean_inc(x_18);
 lean_dec(x_16);
@@ -6473,7 +5997,6 @@ x_11 = l_List_forM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_c
 lean_dec(x_9);
 lean_dec(x_7);
 lean_dec(x_5);
-lean_dec(x_1);
 return x_11;
 }
 }
@@ -6485,7 +6008,6 @@ x_10 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkLetRecsToLiftTypes
 lean_dec(x_8);
 lean_dec(x_6);
 lean_dec(x_4);
-lean_dec(x_1);
 return x_10;
 }
 }
@@ -6999,7 +6521,7 @@ lean_dec(x_2);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -7020,7 +6542,7 @@ lean_inc(x_7);
 x_8 = lean_ctor_get(x_2, 3);
 lean_inc(x_8);
 lean_dec(x_2);
-x_9 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_1, x_6, x_3, x_4);
+x_9 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_1, x_6, x_3, x_4);
 x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
 x_11 = lean_ctor_get(x_9, 1);
@@ -7056,15 +6578,15 @@ lean_object* l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_Fix
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_1, x_2, x_3, x_4);
+x_5 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_1, x_2, x_3, x_4);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_1, x_2, x_3, x_4);
+x_5 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
 return x_5;
 }
@@ -7140,7 +6662,7 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Elab_MutualDef_0__Lean_Elab_Te
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -7183,7 +6705,7 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 if (lean_obj_tag(x_4) == 0)
@@ -7200,7 +6722,7 @@ lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_o
 x_8 = lean_ctor_get(x_4, 0);
 x_9 = lean_ctor_get(x_4, 1);
 x_10 = lean_ctor_get(x_4, 3);
-x_11 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_2, x_3, x_8, x_5, x_6);
+x_11 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_2, x_3, x_8, x_5, x_6);
 x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
 x_13 = lean_ctor_get(x_11, 1);
@@ -7210,7 +6732,7 @@ x_14 = lean_name_eq(x_1, x_9);
 if (x_14 == 0)
 {
 lean_object* x_15; 
-x_15 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_2, x_9);
+x_15 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_2, x_9);
 if (lean_obj_tag(x_15) == 0)
 {
 x_3 = x_12;
@@ -7224,7 +6746,7 @@ lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20;
 x_17 = lean_ctor_get(x_15, 0);
 lean_inc(x_17);
 lean_dec(x_15);
-x_18 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_12, x_17, x_5, x_13);
+x_18 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_merge___spec__1(x_12, x_17, x_5, x_13);
 x_19 = lean_ctor_get(x_18, 0);
 lean_inc(x_19);
 x_20 = lean_ctor_get(x_18, 1);
@@ -7265,7 +6787,7 @@ if (x_5 == 0)
 lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_6 = lean_ctor_get(x_4, 0);
 x_7 = lean_ctor_get(x_4, 1);
-x_8 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_6, x_1);
+x_8 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_6, x_1);
 if (lean_obj_tag(x_8) == 0)
 {
 lean_object* x_9; 
@@ -7283,7 +6805,7 @@ x_10 = lean_ctor_get(x_8, 0);
 lean_inc(x_10);
 lean_dec(x_8);
 lean_inc(x_10);
-x_11 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_6, x_10, x_10, x_2, x_7);
+x_11 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_6, x_10, x_10, x_2, x_7);
 lean_dec(x_10);
 lean_dec(x_6);
 x_12 = lean_ctor_get(x_11, 0);
@@ -7306,7 +6828,7 @@ x_17 = lean_ctor_get(x_4, 1);
 lean_inc(x_17);
 lean_inc(x_16);
 lean_dec(x_4);
-x_18 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_16, x_1);
+x_18 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_16, x_1);
 if (lean_obj_tag(x_18) == 0)
 {
 lean_object* x_19; lean_object* x_20; 
@@ -7325,7 +6847,7 @@ x_21 = lean_ctor_get(x_18, 0);
 lean_inc(x_21);
 lean_dec(x_18);
 lean_inc(x_21);
-x_22 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_16, x_21, x_21, x_2, x_17);
+x_22 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_16, x_21, x_21, x_2, x_17);
 lean_dec(x_21);
 lean_dec(x_16);
 x_23 = lean_ctor_get(x_22, 0);
@@ -7342,21 +6864,21 @@ return x_26;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_Std_RBNode_foldM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Std_RBNode_foldM___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__2(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
@@ -7586,7 +7108,7 @@ return x_12;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_4) == 0)
@@ -7605,7 +7127,7 @@ x_7 = lean_ctor_get(x_4, 3);
 lean_inc(x_7);
 lean_dec(x_4);
 lean_inc(x_2);
-x_8 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(x_1, x_2, x_3, x_5);
+x_8 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(x_1, x_2, x_3, x_5);
 lean_inc(x_2);
 x_9 = l_Lean_LocalContext_contains(x_2, x_6);
 if (x_9 == 0)
@@ -7638,7 +7160,7 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_4) == 0)
@@ -7657,7 +7179,7 @@ x_7 = lean_ctor_get(x_4, 3);
 lean_inc(x_7);
 lean_dec(x_4);
 lean_inc(x_2);
-x_8 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(x_1, x_2, x_3, x_5);
+x_8 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(x_1, x_2, x_3, x_5);
 lean_inc(x_2);
 x_9 = l_Lean_LocalContext_contains(x_2, x_6);
 if (x_9 == 0)
@@ -7710,15 +7232,15 @@ lean_inc(x_7);
 x_8 = lean_ctor_get(x_5, 1);
 lean_inc(x_8);
 lean_dec(x_5);
-x_9 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_2, x_8);
+x_9 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_FixPoint_updateUsedVarsOf___spec__1(x_2, x_8);
 if (lean_obj_tag(x_9) == 0)
 {
 lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-x_10 = l_Lean_NameSet_Inhabited;
+x_10 = l_Lean_NameSet_Lean_Data_Name___instance__7;
 x_11 = l_Option_get_x21___rarg___closed__3;
 x_12 = lean_panic_fn(x_10, x_11);
 x_13 = l_Array_empty___closed__1;
-x_14 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(x_1, x_7, x_13, x_12);
+x_14 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(x_1, x_7, x_13, x_12);
 x_15 = l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(x_4, x_8, x_14);
 x_3 = x_6;
 x_4 = x_15;
@@ -7731,7 +7253,7 @@ x_17 = lean_ctor_get(x_9, 0);
 lean_inc(x_17);
 lean_dec(x_9);
 x_18 = l_Array_empty___closed__1;
-x_19 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(x_1, x_7, x_18, x_17);
+x_19 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(x_1, x_7, x_18, x_17);
 x_20 = l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(x_4, x_8, x_19);
 x_3 = x_6;
 x_4 = x_20;
@@ -7755,20 +7277,20 @@ lean_dec(x_8);
 return x_10;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(x_1, x_2, x_3, x_4);
+x_5 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__2(x_1, x_2, x_3, x_4);
 lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(x_1, x_2, x_3, x_4);
+x_5 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkFreeVarMap___spec__3(x_1, x_2, x_3, x_4);
 lean_dec(x_1);
 return x_5;
 }
@@ -8009,7 +7531,7 @@ lean_dec(x_2);
 return x_9;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -8026,7 +7548,7 @@ lean_inc(x_4);
 x_5 = lean_ctor_get(x_2, 3);
 lean_inc(x_5);
 lean_dec(x_2);
-x_6 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(x_1, x_3);
+x_6 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(x_1, x_3);
 x_7 = l_Array_contains___at___private_Lean_Class_1__checkOutParam___main___spec__1(x_6, x_4);
 if (x_7 == 0)
 {
@@ -8053,7 +7575,7 @@ lean_object* x_3; lean_object* x_4;
 x_3 = lean_ctor_get(x_2, 1);
 lean_inc(x_3);
 lean_dec(x_2);
-x_4 = l_Std_RBNode_fold___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(x_1, x_3);
+x_4 = l_Std_RBNode_fold___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_pushNewVars___spec__1(x_1, x_3);
 return x_4;
 }
 }
@@ -9861,7 +9383,7 @@ lean_dec(x_6);
 return x_14;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -9933,7 +9455,7 @@ x_13 = lean_ctor_get(x_2, 0);
 x_14 = lean_ctor_get(x_2, 1);
 x_15 = lean_ctor_get(x_13, 1);
 lean_inc(x_15);
-x_16 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(x_1, x_15);
+x_16 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(x_1, x_15);
 lean_dec(x_15);
 if (lean_obj_tag(x_16) == 0)
 {
@@ -10160,7 +9682,7 @@ lean_inc(x_55);
 lean_dec(x_2);
 x_57 = lean_ctor_get(x_55, 1);
 lean_inc(x_57);
-x_58 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(x_1, x_57);
+x_58 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(x_1, x_57);
 lean_dec(x_57);
 if (lean_obj_tag(x_58) == 0)
 {
@@ -10388,11 +9910,11 @@ x_10 = l_List_mapM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_M
 return x_10;
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_MutualClosure_mkLetRecClosures___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -10588,7 +10110,7 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Elab_Term_MutualClosure_Replacement_appl
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -10635,7 +10157,7 @@ static lean_object* _init_l_Lean_Expr_ReplaceImpl_replaceUnsafeM___main___at_Lea
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1;
+x_1 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1;
 x_2 = l_Lean_Expr_Inhabited;
 x_3 = l_monadInhabited___rarg(x_1, x_2);
 return x_3;
@@ -10660,7 +10182,7 @@ if (lean_obj_tag(x_3) == 1)
 lean_object* x_163; lean_object* x_164; 
 x_163 = lean_ctor_get(x_3, 0);
 lean_inc(x_163);
-x_164 = l_Std_RBNode_find___main___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_163);
+x_164 = l_Std_RBNode_find___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_163);
 lean_dec(x_163);
 if (lean_obj_tag(x_164) == 0)
 {
@@ -11134,11 +10656,11 @@ lean_dec(x_5);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -14060,6 +13582,7 @@ lean_inc(x_11);
 lean_inc(x_9);
 lean_inc(x_7);
 lean_inc_n(x_41, 2);
+lean_inc(x_6);
 x_43 = l_List_forM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkLetRecsToLiftTypes___spec__1(x_6, x_41, x_41, x_7, x_8, x_9, x_10, x_11, x_12, x_42);
 if (lean_obj_tag(x_43) == 0)
 {
@@ -14285,6 +13808,7 @@ lean_inc(x_11);
 lean_inc(x_9);
 lean_inc(x_7);
 lean_inc_n(x_81, 2);
+lean_inc(x_6);
 x_83 = l_List_forM___main___at___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_checkLetRecsToLiftTypes___spec__1(x_6, x_81, x_81, x_7, x_8, x_9, x_10, x_11, x_12, x_82);
 if (lean_obj_tag(x_83) == 0)
 {
diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c b/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c
index 8cab38e875..8f5ace8887 100644
--- a/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c
+++ b/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c
@@ -18,6 +18,7 @@ lean_object* lean_expr_update_forall(lean_object*, uint8_t, lean_object*, lean_o
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_addAndCompileUnsafeRec___spec__3(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_fixLevelParams___spec__4(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_Expr_ReplaceImpl_replaceUnsafeM___main___at_Lean_Elab_fixLevelParams___spec__3(lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM___main___at_Lean_Elab_addAndCompileUnsafeRec___spec__2(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addAsAxiom(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -110,7 +111,6 @@ lean_object* lean_panic_fn(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_applyAttributesOf___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at_Lean_Elab_fixLevelParams___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_PreDefinition_inhabited___closed__2;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Elab_fixLevelParams_match__1(lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_fixLevelParams___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -2696,7 +2696,7 @@ x_1 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___clos
 x_2 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___closed__2;
 x_3 = lean_unsigned_to_nat(98u);
 x_4 = lean_unsigned_to_nat(25u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Main.c b/stage0/stdlib/Lean/Elab/PreDefinition/Main.c
index bf90f7c5fd..0953c203de 100644
--- a/stage0/stdlib/Lean/Elab/PreDefinition/Main.c
+++ b/stage0/stdlib/Lean/Elab/PreDefinition/Main.c
@@ -20,72 +20,71 @@ lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8
 uint8_t l_Array_anyRangeMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__12(lean_object*, lean_object*, lean_object*);
 size_t l_USize_add(size_t, size_t);
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallBoundedTelescope___at_Lean_Elab_Term_elabLetDeclAux___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*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_addPreDefinitions___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_getMVarsAtPreDef___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
-lean_object* l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___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*);
 extern lean_object* l_Lean_MessageData_ofList___closed__3;
 uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
-lean_object* l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21___boxed(lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21___boxed(lean_object*, lean_object*);
 uint8_t l_Std_HashSetImp_contains___at_Lean_NameHashSet_contains___spec__1(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
 extern lean_object* l_Option_get_x21___rarg___closed__3;
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 lean_object* l_Lean_SCC_scc___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__6___closed__1;
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__1(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___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___lambda__1(lean_object*);
 extern lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_elimRecursion___lambda__2___closed__2;
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__29___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_checkTypesAndAssign___closed__7;
-lean_object* l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addAndCompileUnsafeRec(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7___boxed(lean_object*, lean_object*);
+lean_object* l_Std_mkHashMap___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26(lean_object*);
+lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___lambda__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_PreDefinition_inhabited;
 lean_object* l_ReaderT_bind___at_Lean_Meta_Lean_Meta_Basic___instance__5___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_List_map___main___at_Lean_Elab_addPreDefinitions___spec__7(lean_object*);
 lean_object* l_Lean_MessageData_ofList(lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_ensureNoUnassignedMVarsAtPreDef___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__2___closed__1;
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___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*);
+uint8_t l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___lambda__1(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_reduceRec___rarg___lambda__2___closed__1;
-lean_object* l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7___boxed(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__2(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_USize_decLt(size_t, size_t);
 lean_object* l___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*);
 lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___rarg___lambda__1(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___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_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__4(lean_object*, size_t, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addAndCompileUnsafe(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive_match__1(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SCC_scc___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__6___closed__2;
 lean_object* l___private_Lean_Util_Trace_3__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_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SCC_scc___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__6___boxed(lean_object*, lean_object*);
 lean_object* l_List_map___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__1(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_push___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__11(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_getMVarsAtPreDef_match__1(lean_object*);
 lean_object* l_Lean_Elab_mkInhabitantFor(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__3___closed__2;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1;
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__29(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_AssocList_contains___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__13(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_mkHashMap___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25(lean_object*);
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg___lambda__1(lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(lean_object*, lean_object*);
+lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__30(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__1___closed__3;
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
@@ -93,35 +92,36 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeImp___rarg(
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_mkHashMapImp___rarg(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___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_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(lean_object*, lean_object*, lean_object*);
 size_t l_Lean_Name_hash(lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_collectMVarsAtPreDef(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
+extern lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__9___boxed(lean_object*, lean_object*);
-extern lean_object* l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1;
-lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(lean_object*, lean_object*, lean_object*);
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(lean_object*, lean_object*, lean_object*);
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_structuralRecursion(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_collectMVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__5(lean_object*, size_t, lean_object*, lean_object*, lean_object*);
 size_t lean_usize_modn(size_t, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_CollectMVars_State_inhabited___closed__1;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__4(lean_object*, size_t, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp___rarg___closed__3;
 lean_object* l_List_redLength___main___rarg(lean_object*);
 lean_object* l_Lean_Meta_mapErrorImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs(lean_object*);
 lean_object* l_Std_HashSetImp_insert___at_Lean_NameHashSet_insert___spec__1(lean_object*, lean_object*);
 size_t lean_usize_of_nat(lean_object*);
 lean_object* l_Lean_MessageData_joinSep___main(lean_object*, lean_object*);
 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_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__23(lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__8(lean_object*, lean_object*);
 size_t l_USize_mod(size_t, size_t);
+lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__30___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addPreDefinitions(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_FindImpl_initCache;
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_addPreDefinitions___spec__6(lean_object*, lean_object*);
@@ -136,6 +136,7 @@ lean_object* l_Lean_setEnv___at_Lean_Meta_setInlineAttribute___spec__1(lean_obje
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__20(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_foldlM___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__16(lean_object*, lean_object*);
 lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__1___closed__2;
@@ -145,45 +146,47 @@ lean_object* l_List_map___main___at_Lean_Elab_addPreDefinitions___spec__5(lean_o
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__1___closed__1;
 lean_object* l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__1___boxed(lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setMCtx___at___private_Lean_Meta_Basic_0__Lean_Meta_liftMkBindingM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg___lambda__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_collectMVarsAtPreDef___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_expand___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__14(lean_object*, lean_object*);
 lean_object* l_Std_AssocList_replace___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__17(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__2___closed__2;
 extern lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Term_0__Lean_Elab_Term_applyAttributesCore___spec__1___closed__1;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__1___closed__4;
-lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SCC_scc___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__6(lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_toList___rarg(lean_object*);
-lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__23(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___boxed(lean_object*);
 lean_object* lean_mk_array(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_logUnassignedUsingErrorInfos(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Elab_addPreDefinitions___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_FoldConstsImpl_initCache;
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_WFRecursion___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_indentD(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__2___lambda__1___closed__1;
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(lean_object*, size_t, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
+extern lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1;
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__2___lambda__1___closed__2;
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__2___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_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__1___closed__2;
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_getMVarsAtPreDef(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_forallTelescope___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_addAndCompilePartial___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__8___lambda__3___closed__1;
 lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___boxed(lean_object*);
-lean_object* l___private_Lean_Util_SCC_2__push___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__11(lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_addPreDefinitions___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_Command_initFn____x40_Lean_Elab_DefView___hyg_662____closed__2;
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_addPreDefinitions___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
 lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__20___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -712,530 +715,65 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Main_0__Lea
 return x_2;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
+uint8_t l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; size_t x_103; size_t x_104; lean_object* x_105; size_t x_106; uint8_t x_107; 
-x_103 = lean_ptr_addr(x_3);
-x_104 = x_2 == 0 ? 0 : x_103 % x_2;
-x_105 = lean_array_uget(x_4, x_104);
-x_106 = lean_ptr_addr(x_105);
-lean_dec(x_105);
-x_107 = x_106 == x_103;
-if (x_107 == 0)
+if (lean_obj_tag(x_2) == 4)
 {
-lean_object* x_108; uint8_t x_109; 
-lean_inc(x_3);
-x_108 = lean_array_uset(x_4, x_104, x_3);
-x_109 = 0;
-x_5 = x_109;
-x_6 = x_108;
-goto block_102;
+lean_object* x_3; lean_object* x_4; uint8_t x_5; 
+x_3 = lean_ctor_get(x_2, 0);
+x_4 = lean_ctor_get(x_1, 2);
+x_5 = lean_name_eq(x_4, x_3);
+return x_5;
 }
 else
 {
-uint8_t x_110; 
-x_110 = 1;
-x_5 = x_110;
-x_6 = x_4;
-goto block_102;
-}
-block_102:
-{
-lean_object* x_7; 
-if (x_5 == 0)
-{
-if (lean_obj_tag(x_3) == 4)
-{
-lean_object* x_93; lean_object* x_94; uint8_t x_95; 
-x_93 = lean_ctor_get(x_3, 0);
-lean_inc(x_93);
-x_94 = lean_ctor_get(x_1, 2);
-x_95 = lean_name_eq(x_94, x_93);
-lean_dec(x_93);
-if (x_95 == 0)
-{
-lean_object* x_96; 
-x_96 = lean_box(0);
-x_7 = x_96;
-goto block_92;
-}
-else
-{
-lean_object* x_97; lean_object* x_98; 
-x_97 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_97, 0, x_3);
-x_98 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_98, 0, x_97);
-lean_ctor_set(x_98, 1, x_6);
-return x_98;
-}
-}
-else
-{
-lean_object* x_99; 
-x_99 = lean_box(0);
-x_7 = x_99;
-goto block_92;
-}
-}
-else
-{
-lean_object* x_100; lean_object* x_101; 
-lean_dec(x_3);
-x_100 = lean_box(0);
-x_101 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_101, 0, x_100);
-lean_ctor_set(x_101, 1, x_6);
-return x_101;
-}
-block_92:
-{
-lean_dec(x_7);
-switch (lean_obj_tag(x_3)) {
-case 5:
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-lean_dec(x_3);
-x_10 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(x_1, x_2, x_8, x_6);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-lean_dec(x_10);
-x_3 = x_9;
-x_4 = x_12;
-goto _start;
-}
-else
-{
-uint8_t x_14; 
-lean_dec(x_9);
-x_14 = !lean_is_exclusive(x_10);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_10, 0);
-lean_dec(x_15);
-x_16 = !lean_is_exclusive(x_11);
-if (x_16 == 0)
-{
-return x_10;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-x_17 = lean_ctor_get(x_11, 0);
-lean_inc(x_17);
-lean_dec(x_11);
-x_18 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_10, 0, x_18);
-return x_10;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_10, 1);
-lean_inc(x_19);
-lean_dec(x_10);
-x_20 = lean_ctor_get(x_11, 0);
-lean_inc(x_20);
-if (lean_is_exclusive(x_11)) {
- lean_ctor_release(x_11, 0);
- x_21 = x_11;
-} else {
- lean_dec_ref(x_11);
- x_21 = lean_box(0);
-}
-if (lean_is_scalar(x_21)) {
- x_22 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_22 = x_21;
-}
-lean_ctor_set(x_22, 0, x_20);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_22);
-lean_ctor_set(x_23, 1, x_19);
-return x_23;
-}
-}
-}
-case 6:
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = lean_ctor_get(x_3, 1);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_3, 2);
-lean_inc(x_25);
-lean_dec(x_3);
-x_26 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(x_1, x_2, x_24, x_6);
-x_27 = lean_ctor_get(x_26, 0);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; 
-x_28 = lean_ctor_get(x_26, 1);
-lean_inc(x_28);
-lean_dec(x_26);
-x_3 = x_25;
-x_4 = x_28;
-goto _start;
-}
-else
-{
-uint8_t x_30; 
-lean_dec(x_25);
-x_30 = !lean_is_exclusive(x_26);
-if (x_30 == 0)
-{
-lean_object* x_31; uint8_t x_32; 
-x_31 = lean_ctor_get(x_26, 0);
-lean_dec(x_31);
-x_32 = !lean_is_exclusive(x_27);
-if (x_32 == 0)
-{
-return x_26;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_27, 0);
-lean_inc(x_33);
-lean_dec(x_27);
-x_34 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_34, 0, x_33);
-lean_ctor_set(x_26, 0, x_34);
-return x_26;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_35 = lean_ctor_get(x_26, 1);
-lean_inc(x_35);
-lean_dec(x_26);
-x_36 = lean_ctor_get(x_27, 0);
-lean_inc(x_36);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- x_37 = x_27;
-} else {
- lean_dec_ref(x_27);
- x_37 = lean_box(0);
-}
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_38 = x_37;
-}
-lean_ctor_set(x_38, 0, x_36);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_35);
-return x_39;
-}
-}
-}
-case 7:
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_40 = lean_ctor_get(x_3, 1);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_3, 2);
-lean_inc(x_41);
-lean_dec(x_3);
-x_42 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(x_1, x_2, x_40, x_6);
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; 
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_3 = x_41;
-x_4 = x_44;
-goto _start;
-}
-else
-{
-uint8_t x_46; 
-lean_dec(x_41);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_42, 0);
-lean_dec(x_47);
-x_48 = !lean_is_exclusive(x_43);
-if (x_48 == 0)
-{
-return x_42;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; 
-x_49 = lean_ctor_get(x_43, 0);
-lean_inc(x_49);
-lean_dec(x_43);
-x_50 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_42, 0, x_50);
-return x_42;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_51 = lean_ctor_get(x_42, 1);
-lean_inc(x_51);
-lean_dec(x_42);
-x_52 = lean_ctor_get(x_43, 0);
-lean_inc(x_52);
-if (lean_is_exclusive(x_43)) {
- lean_ctor_release(x_43, 0);
- x_53 = x_43;
-} else {
- lean_dec_ref(x_43);
- x_53 = lean_box(0);
-}
-if (lean_is_scalar(x_53)) {
- x_54 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_54 = x_53;
-}
-lean_ctor_set(x_54, 0, x_52);
-x_55 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_51);
-return x_55;
-}
-}
-}
-case 8:
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_56 = lean_ctor_get(x_3, 1);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_3, 2);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_3, 3);
-lean_inc(x_58);
-lean_dec(x_3);
-x_59 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(x_1, x_2, x_56, x_6);
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_59, 1);
-lean_inc(x_61);
-lean_dec(x_59);
-x_62 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(x_1, x_2, x_57, x_61);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_62, 1);
-lean_inc(x_64);
-lean_dec(x_62);
-x_3 = x_58;
-x_4 = x_64;
-goto _start;
-}
-else
-{
-uint8_t x_66; 
-lean_dec(x_58);
-x_66 = !lean_is_exclusive(x_62);
-if (x_66 == 0)
-{
-lean_object* x_67; uint8_t x_68; 
-x_67 = lean_ctor_get(x_62, 0);
-lean_dec(x_67);
-x_68 = !lean_is_exclusive(x_63);
-if (x_68 == 0)
-{
-return x_62;
-}
-else
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_63, 0);
-lean_inc(x_69);
-lean_dec(x_63);
-x_70 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_62, 0, x_70);
-return x_62;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_71 = lean_ctor_get(x_62, 1);
-lean_inc(x_71);
-lean_dec(x_62);
-x_72 = lean_ctor_get(x_63, 0);
-lean_inc(x_72);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- x_73 = x_63;
-} else {
- lean_dec_ref(x_63);
- x_73 = lean_box(0);
-}
-if (lean_is_scalar(x_73)) {
- x_74 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_74 = x_73;
-}
-lean_ctor_set(x_74, 0, x_72);
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_71);
-return x_75;
-}
-}
-}
-else
-{
-uint8_t x_76; 
-lean_dec(x_58);
-lean_dec(x_57);
-x_76 = !lean_is_exclusive(x_59);
-if (x_76 == 0)
-{
-lean_object* x_77; uint8_t x_78; 
-x_77 = lean_ctor_get(x_59, 0);
-lean_dec(x_77);
-x_78 = !lean_is_exclusive(x_60);
-if (x_78 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_60, 0);
-lean_inc(x_79);
-lean_dec(x_60);
-x_80 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_59, 0, x_80);
-return x_59;
-}
-}
-else
-{
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_81 = lean_ctor_get(x_59, 1);
-lean_inc(x_81);
-lean_dec(x_59);
-x_82 = lean_ctor_get(x_60, 0);
-lean_inc(x_82);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- x_83 = x_60;
-} else {
- lean_dec_ref(x_60);
- x_83 = lean_box(0);
-}
-if (lean_is_scalar(x_83)) {
- x_84 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_84 = x_83;
-}
-lean_ctor_set(x_84, 0, x_82);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_81);
-return x_85;
-}
-}
-}
-case 10:
-{
-lean_object* x_86; 
-x_86 = lean_ctor_get(x_3, 1);
-lean_inc(x_86);
-lean_dec(x_3);
-x_3 = x_86;
-x_4 = x_6;
-goto _start;
-}
-case 11:
-{
-lean_object* x_88; 
-x_88 = lean_ctor_get(x_3, 2);
-lean_inc(x_88);
-lean_dec(x_3);
-x_3 = x_88;
-x_4 = x_6;
-goto _start;
-}
-default: 
-{
-lean_object* x_90; lean_object* x_91; 
-lean_dec(x_3);
-x_90 = lean_box(0);
-x_91 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_6);
-return x_91;
-}
-}
-}
+uint8_t x_6; 
+x_6 = 0;
+return x_6;
 }
 }
 }
 uint8_t l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; size_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_2 = lean_ctor_get(x_1, 4);
-lean_inc(x_2);
-x_3 = 8192;
-x_4 = l_Lean_Expr_FindImpl_initCache;
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(x_1, x_3, x_2, x_4);
+lean_object* x_2; lean_object* x_3; size_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+lean_inc(x_1);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___lambda__1___boxed), 2, 1);
+lean_closure_set(x_2, 0, x_1);
+x_3 = lean_ctor_get(x_1, 4);
+lean_inc(x_3);
 lean_dec(x_1);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-lean_dec(x_5);
-if (lean_obj_tag(x_6) == 0)
+x_4 = 8192;
+x_5 = l_Lean_Expr_FindImpl_initCache;
+x_6 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_2, x_4, x_3, x_5);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_7) == 0)
 {
-uint8_t x_7; 
-x_7 = 1;
-return x_7;
+uint8_t x_8; 
+x_8 = 1;
+return x_8;
 }
 else
 {
-uint8_t x_8; 
-lean_dec(x_6);
-x_8 = 0;
-return x_8;
+uint8_t x_9; 
+lean_dec(x_7);
+x_9 = 0;
+return x_9;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_5; lean_object* x_6; 
-x_5 = lean_unbox_usize(x_2);
+uint8_t x_3; lean_object* x_4; 
+x_3 = l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___lambda__1(x_1, x_2);
 lean_dec(x_2);
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___spec__1(x_1, x_5, x_3, x_4);
 lean_dec(x_1);
-return x_6;
+x_4 = lean_box(x_3);
+return x_4;
 }
 }
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_isNonRecursive___boxed(lean_object* x_1) {
@@ -1995,7 +1533,7 @@ lean_dec(x_7);
 return x_8;
 }
 }
-lean_object* l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; 
@@ -2006,7 +1544,7 @@ lean_dec(x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; 
-x_5 = l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1;
+x_5 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1;
 x_6 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_6, 0, x_5);
 lean_ctor_set(x_6, 1, x_2);
@@ -2337,7 +1875,7 @@ return x_36;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_2__push___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__11(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_push___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__11(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
@@ -2412,7 +1950,7 @@ return x_29;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 uint8_t x_4; 
@@ -2500,13 +2038,13 @@ return x_27;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; lean_object* x_5; 
-x_4 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg___lambda__1), 2, 1);
+x_4 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg___lambda__1), 2, 1);
 lean_closure_set(x_4, 0, x_2);
-x_5 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_1, x_4, x_3);
+x_5 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_1, x_4, x_3);
 return x_5;
 }
 }
@@ -2531,7 +2069,7 @@ lean_inc(x_7);
 x_8 = lean_ctor_get(x_3, 1);
 lean_inc(x_8);
 lean_dec(x_3);
-x_9 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_4);
+x_9 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_4);
 x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
 x_11 = lean_ctor_get(x_10, 0);
@@ -2544,11 +2082,11 @@ x_12 = lean_ctor_get(x_9, 1);
 lean_inc(x_12);
 lean_dec(x_9);
 lean_inc(x_7);
-x_13 = l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(x_1, x_7, x_12);
+x_13 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(x_1, x_7, x_12);
 x_14 = lean_ctor_get(x_13, 1);
 lean_inc(x_14);
 lean_dec(x_13);
-x_15 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_14);
+x_15 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_14);
 lean_dec(x_7);
 x_16 = lean_ctor_get(x_15, 0);
 lean_inc(x_16);
@@ -2559,7 +2097,7 @@ x_18 = lean_ctor_get(x_16, 1);
 lean_inc(x_18);
 lean_dec(x_16);
 lean_inc(x_2);
-x_19 = l___private_Lean_Util_SCC_5__updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_18, x_17);
+x_19 = l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_18, x_17);
 x_20 = lean_ctor_get(x_19, 1);
 lean_inc(x_20);
 lean_dec(x_19);
@@ -2591,7 +2129,7 @@ x_25 = lean_ctor_get(x_9, 1);
 lean_inc(x_25);
 lean_dec(x_9);
 lean_inc(x_2);
-x_26 = l___private_Lean_Util_SCC_5__updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_11, x_25);
+x_26 = l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_11, x_25);
 x_27 = lean_ctor_get(x_26, 1);
 lean_inc(x_27);
 lean_dec(x_26);
@@ -2603,94 +2141,95 @@ goto _start;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__23(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__23(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; 
-x_3 = l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1;
-x_4 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_1, x_3, x_2);
+x_3 = l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1;
+x_4 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_1, x_3, x_2);
 return x_4;
 }
 }
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
 {
-uint8_t x_5; 
-x_5 = !lean_is_exclusive(x_4);
-if (x_5 == 0)
+lean_object* x_5; uint8_t x_6; 
+x_5 = lean_box(0);
+x_6 = !lean_is_exclusive(x_4);
+if (x_6 == 0)
 {
-lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_6 = lean_ctor_get(x_4, 3);
-x_7 = lean_ctor_get(x_4, 0);
-lean_dec(x_7);
-x_8 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_8, 0, x_3);
-lean_ctor_set(x_8, 1, x_6);
-lean_ctor_set(x_4, 3, x_8);
-lean_ctor_set(x_4, 0, x_2);
-x_9 = lean_box(0);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_9);
-lean_ctor_set(x_10, 1, x_4);
-return x_10;
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+x_7 = lean_ctor_get(x_4, 3);
+x_8 = lean_ctor_get(x_4, 0);
+lean_dec(x_8);
+x_9 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_9, 0, x_3);
+lean_ctor_set(x_9, 1, x_7);
+lean_ctor_set(x_4, 3, x_9);
+lean_ctor_set(x_4, 0, x_5);
+x_10 = lean_box(0);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_10);
+lean_ctor_set(x_11, 1, x_4);
+return x_11;
 }
 else
 {
-lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
-x_11 = lean_ctor_get(x_4, 1);
-x_12 = lean_ctor_get(x_4, 2);
-x_13 = lean_ctor_get(x_4, 3);
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_12 = lean_ctor_get(x_4, 1);
+x_13 = lean_ctor_get(x_4, 2);
+x_14 = lean_ctor_get(x_4, 3);
+lean_inc(x_14);
 lean_inc(x_13);
 lean_inc(x_12);
-lean_inc(x_11);
 lean_dec(x_4);
-x_14 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_14, 0, x_3);
-lean_ctor_set(x_14, 1, x_13);
-x_15 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_15, 0, x_2);
-lean_ctor_set(x_15, 1, x_11);
-lean_ctor_set(x_15, 2, x_12);
-lean_ctor_set(x_15, 3, x_14);
-x_16 = lean_box(0);
-x_17 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_17, 0, x_16);
-lean_ctor_set(x_17, 1, x_15);
-return x_17;
+x_15 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_15, 0, x_3);
+lean_ctor_set(x_15, 1, x_14);
+x_16 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_16, 0, x_5);
+lean_ctor_set(x_16, 1, x_12);
+lean_ctor_set(x_16, 2, x_13);
+lean_ctor_set(x_16, 3, x_15);
+x_17 = lean_box(0);
+x_18 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_18, 0, x_17);
+lean_ctor_set(x_18, 1, x_16);
+return x_18;
 }
 }
 else
 {
-uint8_t x_18; 
-x_18 = !lean_is_exclusive(x_2);
-if (x_18 == 0)
+uint8_t x_19; 
+x_19 = !lean_is_exclusive(x_2);
+if (x_19 == 0)
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
-x_19 = lean_ctor_get(x_2, 0);
-x_20 = lean_ctor_get(x_2, 1);
-x_21 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_4__resetOnStack___rarg___lambda__1), 1, 0);
-lean_inc(x_19);
-x_22 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_19, x_21, x_4);
-x_23 = !lean_is_exclusive(x_22);
-if (x_23 == 0)
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_2, 0);
+x_21 = lean_ctor_get(x_2, 1);
+x_22 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___lambda__1), 1, 0);
+lean_inc(x_20);
+x_23 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_20, x_22, x_4);
+x_24 = !lean_is_exclusive(x_23);
+if (x_24 == 0)
 {
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_22, 1);
-x_25 = lean_ctor_get(x_22, 0);
-lean_dec(x_25);
-lean_inc(x_19);
+lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_25 = lean_ctor_get(x_23, 1);
+x_26 = lean_ctor_get(x_23, 0);
+lean_dec(x_26);
+lean_inc(x_20);
 lean_ctor_set(x_2, 1, x_3);
-x_26 = lean_name_eq(x_1, x_19);
-lean_dec(x_19);
-if (x_26 == 0)
+x_27 = lean_name_eq(x_1, x_20);
+lean_dec(x_20);
+if (x_27 == 0)
 {
-lean_free_object(x_22);
+lean_free_object(x_23);
 {
-lean_object* _tmp_1 = x_20;
+lean_object* _tmp_1 = x_21;
 lean_object* _tmp_2 = x_2;
-lean_object* _tmp_3 = x_24;
+lean_object* _tmp_3 = x_25;
 x_2 = _tmp_1;
 x_3 = _tmp_2;
 x_4 = _tmp_3;
@@ -2699,64 +2238,64 @@ goto _start;
 }
 else
 {
-uint8_t x_28; 
-x_28 = !lean_is_exclusive(x_24);
-if (x_28 == 0)
+uint8_t x_29; 
+x_29 = !lean_is_exclusive(x_25);
+if (x_29 == 0)
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_29 = lean_ctor_get(x_24, 3);
-x_30 = lean_ctor_get(x_24, 0);
-lean_dec(x_30);
-x_31 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_31, 0, x_2);
-lean_ctor_set(x_31, 1, x_29);
-lean_ctor_set(x_24, 3, x_31);
-lean_ctor_set(x_24, 0, x_20);
-x_32 = lean_box(0);
-lean_ctor_set(x_22, 0, x_32);
-return x_22;
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_30 = lean_ctor_get(x_25, 3);
+x_31 = lean_ctor_get(x_25, 0);
+lean_dec(x_31);
+x_32 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_32, 0, x_2);
+lean_ctor_set(x_32, 1, x_30);
+lean_ctor_set(x_25, 3, x_32);
+lean_ctor_set(x_25, 0, x_21);
+x_33 = lean_box(0);
+lean_ctor_set(x_23, 0, x_33);
+return x_23;
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_33 = lean_ctor_get(x_24, 1);
-x_34 = lean_ctor_get(x_24, 2);
-x_35 = lean_ctor_get(x_24, 3);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
+x_34 = lean_ctor_get(x_25, 1);
+x_35 = lean_ctor_get(x_25, 2);
+x_36 = lean_ctor_get(x_25, 3);
+lean_inc(x_36);
 lean_inc(x_35);
 lean_inc(x_34);
-lean_inc(x_33);
-lean_dec(x_24);
-x_36 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_36, 0, x_2);
-lean_ctor_set(x_36, 1, x_35);
-x_37 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_37, 0, x_20);
-lean_ctor_set(x_37, 1, x_33);
-lean_ctor_set(x_37, 2, x_34);
-lean_ctor_set(x_37, 3, x_36);
-x_38 = lean_box(0);
-lean_ctor_set(x_22, 1, x_37);
-lean_ctor_set(x_22, 0, x_38);
-return x_22;
+lean_dec(x_25);
+x_37 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_37, 0, x_2);
+lean_ctor_set(x_37, 1, x_36);
+x_38 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_38, 0, x_21);
+lean_ctor_set(x_38, 1, x_34);
+lean_ctor_set(x_38, 2, x_35);
+lean_ctor_set(x_38, 3, x_37);
+x_39 = lean_box(0);
+lean_ctor_set(x_23, 1, x_38);
+lean_ctor_set(x_23, 0, x_39);
+return x_23;
 }
 }
 }
 else
 {
-lean_object* x_39; uint8_t x_40; 
-x_39 = lean_ctor_get(x_22, 1);
-lean_inc(x_39);
-lean_dec(x_22);
-lean_inc(x_19);
+lean_object* x_40; uint8_t x_41; 
+x_40 = lean_ctor_get(x_23, 1);
+lean_inc(x_40);
+lean_dec(x_23);
+lean_inc(x_20);
 lean_ctor_set(x_2, 1, x_3);
-x_40 = lean_name_eq(x_1, x_19);
-lean_dec(x_19);
-if (x_40 == 0)
+x_41 = lean_name_eq(x_1, x_20);
+lean_dec(x_20);
+if (x_41 == 0)
 {
 {
-lean_object* _tmp_1 = x_20;
+lean_object* _tmp_1 = x_21;
 lean_object* _tmp_2 = x_2;
-lean_object* _tmp_3 = x_39;
+lean_object* _tmp_3 = x_40;
 x_2 = _tmp_1;
 x_3 = _tmp_2;
 x_4 = _tmp_3;
@@ -2765,135 +2304,348 @@ goto _start;
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_42 = lean_ctor_get(x_39, 1);
-lean_inc(x_42);
-x_43 = lean_ctor_get(x_39, 2);
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
+x_43 = lean_ctor_get(x_40, 1);
 lean_inc(x_43);
-x_44 = lean_ctor_get(x_39, 3);
+x_44 = lean_ctor_get(x_40, 2);
 lean_inc(x_44);
-if (lean_is_exclusive(x_39)) {
- lean_ctor_release(x_39, 0);
- lean_ctor_release(x_39, 1);
- lean_ctor_release(x_39, 2);
- lean_ctor_release(x_39, 3);
- x_45 = x_39;
+x_45 = lean_ctor_get(x_40, 3);
+lean_inc(x_45);
+if (lean_is_exclusive(x_40)) {
+ lean_ctor_release(x_40, 0);
+ lean_ctor_release(x_40, 1);
+ lean_ctor_release(x_40, 2);
+ lean_ctor_release(x_40, 3);
+ x_46 = x_40;
 } else {
- lean_dec_ref(x_39);
- x_45 = lean_box(0);
+ lean_dec_ref(x_40);
+ x_46 = lean_box(0);
 }
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_2);
-lean_ctor_set(x_46, 1, x_44);
-if (lean_is_scalar(x_45)) {
- x_47 = lean_alloc_ctor(0, 4, 0);
+x_47 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_47, 0, x_2);
+lean_ctor_set(x_47, 1, x_45);
+if (lean_is_scalar(x_46)) {
+ x_48 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_47 = x_45;
+ x_48 = x_46;
 }
-lean_ctor_set(x_47, 0, x_20);
-lean_ctor_set(x_47, 1, x_42);
-lean_ctor_set(x_47, 2, x_43);
-lean_ctor_set(x_47, 3, x_46);
-x_48 = lean_box(0);
-x_49 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_49, 1, x_47);
-return x_49;
+lean_ctor_set(x_48, 0, x_21);
+lean_ctor_set(x_48, 1, x_43);
+lean_ctor_set(x_48, 2, x_44);
+lean_ctor_set(x_48, 3, x_47);
+x_49 = lean_box(0);
+x_50 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_50, 0, x_49);
+lean_ctor_set(x_50, 1, x_48);
+return x_50;
 }
 }
 }
 else
 {
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; 
-x_50 = lean_ctor_get(x_2, 0);
-x_51 = lean_ctor_get(x_2, 1);
+lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; 
+x_51 = lean_ctor_get(x_2, 0);
+x_52 = lean_ctor_get(x_2, 1);
+lean_inc(x_52);
 lean_inc(x_51);
-lean_inc(x_50);
 lean_dec(x_2);
-x_52 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_4__resetOnStack___rarg___lambda__1), 1, 0);
-lean_inc(x_50);
-x_53 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_50, x_52, x_4);
-x_54 = lean_ctor_get(x_53, 1);
-lean_inc(x_54);
-if (lean_is_exclusive(x_53)) {
- lean_ctor_release(x_53, 0);
- lean_ctor_release(x_53, 1);
- x_55 = x_53;
-} else {
- lean_dec_ref(x_53);
- x_55 = lean_box(0);
-}
-lean_inc(x_50);
-x_56 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_56, 0, x_50);
-lean_ctor_set(x_56, 1, x_3);
-x_57 = lean_name_eq(x_1, x_50);
-lean_dec(x_50);
-if (x_57 == 0)
-{
-lean_dec(x_55);
-x_2 = x_51;
-x_3 = x_56;
-x_4 = x_54;
-goto _start;
-}
-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; 
-x_59 = lean_ctor_get(x_54, 1);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_54, 2);
-lean_inc(x_60);
-x_61 = lean_ctor_get(x_54, 3);
-lean_inc(x_61);
+x_53 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___lambda__1), 1, 0);
+lean_inc(x_51);
+x_54 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__19(x_51, x_53, x_4);
+x_55 = lean_ctor_get(x_54, 1);
+lean_inc(x_55);
 if (lean_is_exclusive(x_54)) {
  lean_ctor_release(x_54, 0);
  lean_ctor_release(x_54, 1);
- lean_ctor_release(x_54, 2);
- lean_ctor_release(x_54, 3);
- x_62 = x_54;
+ x_56 = x_54;
 } else {
  lean_dec_ref(x_54);
- x_62 = lean_box(0);
+ x_56 = lean_box(0);
 }
-x_63 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_63, 0, x_56);
-lean_ctor_set(x_63, 1, x_61);
-if (lean_is_scalar(x_62)) {
- x_64 = lean_alloc_ctor(0, 4, 0);
+lean_inc(x_51);
+x_57 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_57, 0, x_51);
+lean_ctor_set(x_57, 1, x_3);
+x_58 = lean_name_eq(x_1, x_51);
+lean_dec(x_51);
+if (x_58 == 0)
+{
+lean_dec(x_56);
+x_2 = x_52;
+x_3 = x_57;
+x_4 = x_55;
+goto _start;
+}
+else
+{
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; 
+x_60 = lean_ctor_get(x_55, 1);
+lean_inc(x_60);
+x_61 = lean_ctor_get(x_55, 2);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_55, 3);
+lean_inc(x_62);
+if (lean_is_exclusive(x_55)) {
+ lean_ctor_release(x_55, 0);
+ lean_ctor_release(x_55, 1);
+ lean_ctor_release(x_55, 2);
+ lean_ctor_release(x_55, 3);
+ x_63 = x_55;
 } else {
- x_64 = x_62;
+ lean_dec_ref(x_55);
+ x_63 = lean_box(0);
 }
-lean_ctor_set(x_64, 0, x_51);
-lean_ctor_set(x_64, 1, x_59);
-lean_ctor_set(x_64, 2, x_60);
-lean_ctor_set(x_64, 3, x_63);
-x_65 = lean_box(0);
-if (lean_is_scalar(x_55)) {
- x_66 = lean_alloc_ctor(0, 2, 0);
+x_64 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_64, 0, x_57);
+lean_ctor_set(x_64, 1, x_62);
+if (lean_is_scalar(x_63)) {
+ x_65 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_66 = x_55;
+ x_65 = x_63;
 }
-lean_ctor_set(x_66, 0, x_65);
-lean_ctor_set(x_66, 1, x_64);
-return x_66;
+lean_ctor_set(x_65, 0, x_52);
+lean_ctor_set(x_65, 1, x_60);
+lean_ctor_set(x_65, 2, x_61);
+lean_ctor_set(x_65, 3, x_64);
+x_66 = lean_box(0);
+if (lean_is_scalar(x_56)) {
+ x_67 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_67 = x_56;
+}
+lean_ctor_set(x_67, 0, x_66);
+lean_ctor_set(x_67, 1, x_65);
+return x_67;
 }
 }
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; 
 x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
 x_4 = lean_box(0);
-x_5 = l___private_Lean_Util_SCC_6__addSCCAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(x_1, x_3, x_4, x_2);
+x_5 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(x_1, x_3, x_4, x_2);
 return x_5;
 }
 }
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_44; lean_object* x_45; lean_object* x_46; size_t x_47; 
+lean_inc(x_2);
+x_4 = l___private_Lean_Util_SCC_0__Lean_SCC_push___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__11(x_2, x_3);
+x_5 = lean_ctor_get(x_4, 1);
+lean_inc(x_5);
+lean_dec(x_4);
+x_44 = lean_unsigned_to_nat(0u);
+x_45 = l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__2(x_2, x_1, x_44);
+x_46 = lean_box(0);
+x_47 = 8192;
+if (lean_obj_tag(x_45) == 0)
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
+x_48 = l_Lean_Elab_PreDefinition_inhabited;
+x_49 = l_Option_get_x21___rarg___closed__3;
+x_50 = lean_panic_fn(x_48, x_49);
+x_51 = lean_ctor_get(x_50, 4);
+lean_inc(x_51);
+lean_dec(x_50);
+x_52 = l_Lean_Expr_FoldConstsImpl_initCache;
+x_53 = l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__4(x_1, x_47, x_51, x_46, x_52);
+x_54 = lean_ctor_get(x_53, 0);
+lean_inc(x_54);
+lean_dec(x_53);
+x_6 = x_54;
+goto block_43;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_55 = lean_ctor_get(x_45, 0);
+lean_inc(x_55);
+lean_dec(x_45);
+x_56 = lean_ctor_get(x_55, 4);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_Expr_FoldConstsImpl_initCache;
+x_58 = l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__5(x_1, x_47, x_56, x_46, x_57);
+x_59 = lean_ctor_get(x_58, 0);
+lean_inc(x_59);
+lean_dec(x_58);
+x_6 = x_59;
+goto block_43;
+}
+block_43:
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_inc(x_2);
+x_7 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__20(x_1, x_2, x_6, x_5);
+x_8 = lean_ctor_get(x_7, 1);
+lean_inc(x_8);
+lean_dec(x_7);
+x_9 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_2, x_8);
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_10, 1);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_object* x_12; 
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+lean_dec(x_10);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_object* x_13; lean_object* x_14; 
+x_13 = lean_ctor_get(x_9, 1);
+lean_inc(x_13);
+lean_dec(x_9);
+x_14 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_13);
+lean_dec(x_2);
+return x_14;
+}
+else
+{
+uint8_t x_15; 
+lean_dec(x_12);
+lean_dec(x_2);
+x_15 = !lean_is_exclusive(x_9);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; 
+x_16 = lean_ctor_get(x_9, 0);
+lean_dec(x_16);
+x_17 = lean_box(0);
+lean_ctor_set(x_9, 0, x_17);
+return x_9;
+}
+else
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_9, 1);
+lean_inc(x_18);
+lean_dec(x_9);
+x_19 = lean_box(0);
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_18);
+return x_20;
+}
+}
+}
+else
+{
+lean_object* x_21; 
+x_21 = lean_ctor_get(x_10, 0);
+lean_inc(x_21);
+lean_dec(x_10);
+if (lean_obj_tag(x_21) == 0)
+{
+uint8_t x_22; 
+lean_dec(x_11);
+lean_dec(x_2);
+x_22 = !lean_is_exclusive(x_9);
+if (x_22 == 0)
+{
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_9, 0);
+lean_dec(x_23);
+x_24 = lean_box(0);
+lean_ctor_set(x_9, 0, x_24);
+return x_9;
+}
+else
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = lean_ctor_get(x_9, 1);
+lean_inc(x_25);
+lean_dec(x_9);
+x_26 = lean_box(0);
+x_27 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_27, 0, x_26);
+lean_ctor_set(x_27, 1, x_25);
+return x_27;
+}
+}
+else
+{
+uint8_t x_28; 
+x_28 = !lean_is_exclusive(x_9);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; 
+x_29 = lean_ctor_get(x_9, 1);
+x_30 = lean_ctor_get(x_9, 0);
+lean_dec(x_30);
+x_31 = lean_ctor_get(x_11, 0);
+lean_inc(x_31);
+lean_dec(x_11);
+x_32 = lean_ctor_get(x_21, 0);
+lean_inc(x_32);
+lean_dec(x_21);
+x_33 = lean_nat_dec_eq(x_31, x_32);
+lean_dec(x_32);
+lean_dec(x_31);
+if (x_33 == 0)
+{
+lean_object* x_34; 
+lean_dec(x_2);
+x_34 = lean_box(0);
+lean_ctor_set(x_9, 0, x_34);
+return x_9;
+}
+else
+{
+lean_object* x_35; 
+lean_free_object(x_9);
+x_35 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_29);
+lean_dec(x_2);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_36 = lean_ctor_get(x_9, 1);
+lean_inc(x_36);
+lean_dec(x_9);
+x_37 = lean_ctor_get(x_11, 0);
+lean_inc(x_37);
+lean_dec(x_11);
+x_38 = lean_ctor_get(x_21, 0);
+lean_inc(x_38);
+lean_dec(x_21);
+x_39 = lean_nat_dec_eq(x_37, x_38);
+lean_dec(x_38);
+lean_dec(x_37);
+if (x_39 == 0)
+{
+lean_object* x_40; lean_object* x_41; 
+lean_dec(x_2);
+x_40 = lean_box(0);
+x_41 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_41, 0, x_40);
+lean_ctor_set(x_41, 1, x_36);
+return x_41;
+}
+else
+{
+lean_object* x_42; 
+x_42 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_36);
+lean_dec(x_2);
+return x_42;
+}
+}
+}
+}
+}
+}
+}
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -2914,7 +2666,7 @@ lean_inc(x_7);
 x_8 = lean_ctor_get(x_3, 1);
 lean_inc(x_8);
 lean_dec(x_3);
-x_9 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_4);
+x_9 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_4);
 x_10 = lean_ctor_get(x_9, 0);
 lean_inc(x_10);
 x_11 = lean_ctor_get(x_10, 0);
@@ -2927,11 +2679,11 @@ x_12 = lean_ctor_get(x_9, 1);
 lean_inc(x_12);
 lean_dec(x_9);
 lean_inc(x_7);
-x_13 = l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(x_1, x_7, x_12);
+x_13 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(x_1, x_7, x_12);
 x_14 = lean_ctor_get(x_13, 1);
 lean_inc(x_14);
 lean_dec(x_13);
-x_15 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_14);
+x_15 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_7, x_14);
 lean_dec(x_7);
 x_16 = lean_ctor_get(x_15, 0);
 lean_inc(x_16);
@@ -2942,7 +2694,7 @@ x_18 = lean_ctor_get(x_16, 1);
 lean_inc(x_18);
 lean_dec(x_16);
 lean_inc(x_2);
-x_19 = l___private_Lean_Util_SCC_5__updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_18, x_17);
+x_19 = l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_18, x_17);
 x_20 = lean_ctor_get(x_19, 1);
 lean_inc(x_20);
 lean_dec(x_19);
@@ -2974,7 +2726,7 @@ x_25 = lean_ctor_get(x_9, 1);
 lean_inc(x_25);
 lean_dec(x_9);
 lean_inc(x_2);
-x_26 = l___private_Lean_Util_SCC_5__updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_11, x_25);
+x_26 = l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__18(x_2, x_11, x_25);
 x_27 = lean_ctor_get(x_26, 1);
 lean_inc(x_27);
 lean_dec(x_26);
@@ -2986,364 +2738,212 @@ goto _start;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; size_t x_9; 
+lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_44; lean_object* x_45; lean_object* x_46; size_t x_47; 
 lean_inc(x_2);
-x_4 = l___private_Lean_Util_SCC_2__push___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__11(x_2, x_3);
+x_4 = l___private_Lean_Util_SCC_0__Lean_SCC_push___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__11(x_2, x_3);
 x_5 = lean_ctor_get(x_4, 1);
 lean_inc(x_5);
 lean_dec(x_4);
-x_6 = lean_unsigned_to_nat(0u);
-x_7 = l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__2(x_2, x_1, x_6);
-x_8 = lean_box(0);
-x_9 = 8192;
-if (lean_obj_tag(x_7) == 0)
+x_44 = lean_unsigned_to_nat(0u);
+x_45 = l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__2(x_2, x_1, x_44);
+x_46 = lean_box(0);
+x_47 = 8192;
+if (lean_obj_tag(x_45) == 0)
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_10 = l_Lean_Elab_PreDefinition_inhabited;
-x_11 = l_Option_get_x21___rarg___closed__3;
-x_12 = lean_panic_fn(x_10, x_11);
-x_13 = lean_ctor_get(x_12, 4);
-lean_inc(x_13);
-lean_dec(x_12);
-x_14 = l_Lean_Expr_FoldConstsImpl_initCache;
-x_15 = l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__4(x_1, x_9, x_13, x_8, x_14);
-x_16 = lean_ctor_get(x_15, 0);
-lean_inc(x_16);
-lean_dec(x_15);
-lean_inc(x_2);
-x_17 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__20(x_1, x_2, x_16, x_5);
-x_18 = lean_ctor_get(x_17, 1);
-lean_inc(x_18);
-lean_dec(x_17);
-x_19 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_2, x_18);
-x_20 = lean_ctor_get(x_19, 0);
-lean_inc(x_20);
-x_21 = lean_ctor_get(x_20, 1);
-lean_inc(x_21);
-if (lean_obj_tag(x_21) == 0)
-{
-lean_object* x_22; 
-x_22 = lean_ctor_get(x_20, 0);
-lean_inc(x_22);
-lean_dec(x_20);
-if (lean_obj_tag(x_22) == 0)
-{
-lean_object* x_23; lean_object* x_24; 
-x_23 = lean_ctor_get(x_19, 1);
-lean_inc(x_23);
-lean_dec(x_19);
-x_24 = l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_23);
-lean_dec(x_2);
-return x_24;
-}
-else
-{
-uint8_t x_25; 
-lean_dec(x_22);
-lean_dec(x_2);
-x_25 = !lean_is_exclusive(x_19);
-if (x_25 == 0)
-{
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_19, 0);
-lean_dec(x_26);
-x_27 = lean_box(0);
-lean_ctor_set(x_19, 0, x_27);
-return x_19;
-}
-else
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_28 = lean_ctor_get(x_19, 1);
-lean_inc(x_28);
-lean_dec(x_19);
-x_29 = lean_box(0);
-x_30 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_30, 0, x_29);
-lean_ctor_set(x_30, 1, x_28);
-return x_30;
-}
-}
-}
-else
-{
-lean_object* x_31; 
-x_31 = lean_ctor_get(x_20, 0);
-lean_inc(x_31);
-lean_dec(x_20);
-if (lean_obj_tag(x_31) == 0)
-{
-uint8_t x_32; 
-lean_dec(x_21);
-lean_dec(x_2);
-x_32 = !lean_is_exclusive(x_19);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_19, 0);
-lean_dec(x_33);
-x_34 = lean_box(0);
-lean_ctor_set(x_19, 0, x_34);
-return x_19;
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_35 = lean_ctor_get(x_19, 1);
-lean_inc(x_35);
-lean_dec(x_19);
-x_36 = lean_box(0);
-x_37 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_37, 0, x_36);
-lean_ctor_set(x_37, 1, x_35);
-return x_37;
-}
-}
-else
-{
-uint8_t x_38; 
-x_38 = !lean_is_exclusive(x_19);
-if (x_38 == 0)
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; 
-x_39 = lean_ctor_get(x_19, 1);
-x_40 = lean_ctor_get(x_19, 0);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_21, 0);
-lean_inc(x_41);
-lean_dec(x_21);
-x_42 = lean_ctor_get(x_31, 0);
-lean_inc(x_42);
-lean_dec(x_31);
-x_43 = lean_nat_dec_eq(x_41, x_42);
-lean_dec(x_42);
-lean_dec(x_41);
-if (x_43 == 0)
-{
-lean_object* x_44; 
-lean_dec(x_2);
-x_44 = lean_box(0);
-lean_ctor_set(x_19, 0, x_44);
-return x_19;
-}
-else
-{
-lean_object* x_45; 
-lean_free_object(x_19);
-x_45 = l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_39);
-lean_dec(x_2);
-return x_45;
-}
-}
-else
-{
-lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; 
-x_46 = lean_ctor_get(x_19, 1);
-lean_inc(x_46);
-lean_dec(x_19);
-x_47 = lean_ctor_get(x_21, 0);
-lean_inc(x_47);
-lean_dec(x_21);
-x_48 = lean_ctor_get(x_31, 0);
-lean_inc(x_48);
-lean_dec(x_31);
-x_49 = lean_nat_dec_eq(x_47, x_48);
-lean_dec(x_48);
-lean_dec(x_47);
-if (x_49 == 0)
-{
-lean_object* x_50; lean_object* x_51; 
-lean_dec(x_2);
-x_50 = lean_box(0);
-x_51 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_51, 0, x_50);
-lean_ctor_set(x_51, 1, x_46);
-return x_51;
-}
-else
-{
-lean_object* x_52; 
-x_52 = l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_46);
-lean_dec(x_2);
-return x_52;
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-x_53 = lean_ctor_get(x_7, 0);
-lean_inc(x_53);
-lean_dec(x_7);
-x_54 = lean_ctor_get(x_53, 4);
+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; 
+x_48 = l_Lean_Elab_PreDefinition_inhabited;
+x_49 = l_Option_get_x21___rarg___closed__3;
+x_50 = lean_panic_fn(x_48, x_49);
+x_51 = lean_ctor_get(x_50, 4);
+lean_inc(x_51);
+lean_dec(x_50);
+x_52 = l_Lean_Expr_FoldConstsImpl_initCache;
+x_53 = l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__4(x_1, x_47, x_51, x_46, x_52);
+x_54 = lean_ctor_get(x_53, 0);
 lean_inc(x_54);
 lean_dec(x_53);
-x_55 = l_Lean_Expr_FoldConstsImpl_initCache;
-x_56 = l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__5(x_1, x_9, x_54, x_8, x_55);
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-lean_dec(x_56);
-lean_inc(x_2);
-x_58 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(x_1, x_2, x_57, x_5);
-x_59 = lean_ctor_get(x_58, 1);
+x_6 = x_54;
+goto block_43;
+}
+else
+{
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_55 = lean_ctor_get(x_45, 0);
+lean_inc(x_55);
+lean_dec(x_45);
+x_56 = lean_ctor_get(x_55, 4);
+lean_inc(x_56);
+lean_dec(x_55);
+x_57 = l_Lean_Expr_FoldConstsImpl_initCache;
+x_58 = l_Lean_Expr_FoldConstsImpl_fold___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__5(x_1, x_47, x_56, x_46, x_57);
+x_59 = lean_ctor_get(x_58, 0);
 lean_inc(x_59);
 lean_dec(x_58);
-x_60 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_2, x_59);
-x_61 = lean_ctor_get(x_60, 0);
-lean_inc(x_61);
-x_62 = lean_ctor_get(x_61, 1);
-lean_inc(x_62);
-if (lean_obj_tag(x_62) == 0)
+x_6 = x_59;
+goto block_43;
+}
+block_43:
 {
-lean_object* x_63; 
-x_63 = lean_ctor_get(x_61, 0);
-lean_inc(x_63);
-lean_dec(x_61);
-if (lean_obj_tag(x_63) == 0)
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_inc(x_2);
+x_7 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25(x_1, x_2, x_6, x_5);
+x_8 = lean_ctor_get(x_7, 1);
+lean_inc(x_8);
+lean_dec(x_7);
+x_9 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_2, x_8);
+x_10 = lean_ctor_get(x_9, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_10, 1);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
 {
-lean_object* x_64; lean_object* x_65; 
-x_64 = lean_ctor_get(x_60, 1);
-lean_inc(x_64);
-lean_dec(x_60);
-x_65 = l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_64);
+lean_object* x_12; 
+x_12 = lean_ctor_get(x_10, 0);
+lean_inc(x_12);
+lean_dec(x_10);
+if (lean_obj_tag(x_12) == 0)
+{
+lean_object* x_13; lean_object* x_14; 
+x_13 = lean_ctor_get(x_9, 1);
+lean_inc(x_13);
+lean_dec(x_9);
+x_14 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_13);
 lean_dec(x_2);
-return x_65;
+return x_14;
 }
 else
 {
-uint8_t x_66; 
-lean_dec(x_63);
+uint8_t x_15; 
+lean_dec(x_12);
 lean_dec(x_2);
-x_66 = !lean_is_exclusive(x_60);
-if (x_66 == 0)
+x_15 = !lean_is_exclusive(x_9);
+if (x_15 == 0)
 {
-lean_object* x_67; lean_object* x_68; 
-x_67 = lean_ctor_get(x_60, 0);
-lean_dec(x_67);
-x_68 = lean_box(0);
-lean_ctor_set(x_60, 0, x_68);
-return x_60;
+lean_object* x_16; lean_object* x_17; 
+x_16 = lean_ctor_get(x_9, 0);
+lean_dec(x_16);
+x_17 = lean_box(0);
+lean_ctor_set(x_9, 0, x_17);
+return x_9;
 }
 else
 {
-lean_object* x_69; lean_object* x_70; lean_object* x_71; 
-x_69 = lean_ctor_get(x_60, 1);
-lean_inc(x_69);
-lean_dec(x_60);
-x_70 = lean_box(0);
-x_71 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_71, 1, x_69);
-return x_71;
+lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+x_18 = lean_ctor_get(x_9, 1);
+lean_inc(x_18);
+lean_dec(x_9);
+x_19 = lean_box(0);
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_18);
+return x_20;
 }
 }
 }
 else
 {
-lean_object* x_72; 
-x_72 = lean_ctor_get(x_61, 0);
-lean_inc(x_72);
-lean_dec(x_61);
-if (lean_obj_tag(x_72) == 0)
+lean_object* x_21; 
+x_21 = lean_ctor_get(x_10, 0);
+lean_inc(x_21);
+lean_dec(x_10);
+if (lean_obj_tag(x_21) == 0)
 {
-uint8_t x_73; 
-lean_dec(x_62);
+uint8_t x_22; 
+lean_dec(x_11);
 lean_dec(x_2);
-x_73 = !lean_is_exclusive(x_60);
-if (x_73 == 0)
+x_22 = !lean_is_exclusive(x_9);
+if (x_22 == 0)
 {
-lean_object* x_74; lean_object* x_75; 
-x_74 = lean_ctor_get(x_60, 0);
-lean_dec(x_74);
-x_75 = lean_box(0);
-lean_ctor_set(x_60, 0, x_75);
-return x_60;
+lean_object* x_23; lean_object* x_24; 
+x_23 = lean_ctor_get(x_9, 0);
+lean_dec(x_23);
+x_24 = lean_box(0);
+lean_ctor_set(x_9, 0, x_24);
+return x_9;
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; 
-x_76 = lean_ctor_get(x_60, 1);
-lean_inc(x_76);
-lean_dec(x_60);
-x_77 = lean_box(0);
-x_78 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_78, 0, x_77);
-lean_ctor_set(x_78, 1, x_76);
-return x_78;
+lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_25 = lean_ctor_get(x_9, 1);
+lean_inc(x_25);
+lean_dec(x_9);
+x_26 = lean_box(0);
+x_27 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_27, 0, x_26);
+lean_ctor_set(x_27, 1, x_25);
+return x_27;
 }
 }
 else
 {
-uint8_t x_79; 
-x_79 = !lean_is_exclusive(x_60);
-if (x_79 == 0)
+uint8_t x_28; 
+x_28 = !lean_is_exclusive(x_9);
+if (x_28 == 0)
 {
-lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; uint8_t x_84; 
-x_80 = lean_ctor_get(x_60, 1);
-x_81 = lean_ctor_get(x_60, 0);
-lean_dec(x_81);
-x_82 = lean_ctor_get(x_62, 0);
-lean_inc(x_82);
-lean_dec(x_62);
-x_83 = lean_ctor_get(x_72, 0);
-lean_inc(x_83);
-lean_dec(x_72);
-x_84 = lean_nat_dec_eq(x_82, x_83);
-lean_dec(x_83);
-lean_dec(x_82);
-if (x_84 == 0)
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; 
+x_29 = lean_ctor_get(x_9, 1);
+x_30 = lean_ctor_get(x_9, 0);
+lean_dec(x_30);
+x_31 = lean_ctor_get(x_11, 0);
+lean_inc(x_31);
+lean_dec(x_11);
+x_32 = lean_ctor_get(x_21, 0);
+lean_inc(x_32);
+lean_dec(x_21);
+x_33 = lean_nat_dec_eq(x_31, x_32);
+lean_dec(x_32);
+lean_dec(x_31);
+if (x_33 == 0)
 {
-lean_object* x_85; 
+lean_object* x_34; 
 lean_dec(x_2);
-x_85 = lean_box(0);
-lean_ctor_set(x_60, 0, x_85);
-return x_60;
+x_34 = lean_box(0);
+lean_ctor_set(x_9, 0, x_34);
+return x_9;
 }
 else
 {
-lean_object* x_86; 
-lean_free_object(x_60);
-x_86 = l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_80);
+lean_object* x_35; 
+lean_free_object(x_9);
+x_35 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_29);
 lean_dec(x_2);
-return x_86;
+return x_35;
 }
 }
 else
 {
-lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; 
-x_87 = lean_ctor_get(x_60, 1);
-lean_inc(x_87);
-lean_dec(x_60);
-x_88 = lean_ctor_get(x_62, 0);
-lean_inc(x_88);
-lean_dec(x_62);
-x_89 = lean_ctor_get(x_72, 0);
-lean_inc(x_89);
-lean_dec(x_72);
-x_90 = lean_nat_dec_eq(x_88, x_89);
-lean_dec(x_89);
-lean_dec(x_88);
-if (x_90 == 0)
+lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_36 = lean_ctor_get(x_9, 1);
+lean_inc(x_36);
+lean_dec(x_9);
+x_37 = lean_ctor_get(x_11, 0);
+lean_inc(x_37);
+lean_dec(x_11);
+x_38 = lean_ctor_get(x_21, 0);
+lean_inc(x_38);
+lean_dec(x_21);
+x_39 = lean_nat_dec_eq(x_37, x_38);
+lean_dec(x_38);
+lean_dec(x_37);
+if (x_39 == 0)
 {
-lean_object* x_91; lean_object* x_92; 
+lean_object* x_40; lean_object* x_41; 
 lean_dec(x_2);
-x_91 = lean_box(0);
-x_92 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_92, 0, x_91);
-lean_ctor_set(x_92, 1, x_87);
-return x_92;
+x_40 = lean_box(0);
+x_41 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_41, 0, x_40);
+lean_ctor_set(x_41, 1, x_36);
+return x_41;
 }
 else
 {
-lean_object* x_93; 
-x_93 = l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_87);
+lean_object* x_42; 
+x_42 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_2, x_36);
 lean_dec(x_2);
-return x_93;
+return x_42;
 }
 }
 }
@@ -3351,7 +2951,7 @@ return x_93;
 }
 }
 }
-lean_object* l_Std_mkHashMap___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25(lean_object* x_1) {
+lean_object* l_Std_mkHashMap___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -3359,7 +2959,7 @@ x_2 = l_Std_mkHashMapImp___rarg(x_1);
 return x_2;
 }
 }
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -3379,7 +2979,7 @@ lean_inc(x_6);
 x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
 lean_dec(x_2);
-x_8 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_6, x_3);
+x_8 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_6, x_3);
 x_9 = lean_ctor_get(x_8, 0);
 lean_inc(x_9);
 x_10 = lean_ctor_get(x_9, 0);
@@ -3391,7 +2991,7 @@ lean_object* x_11; lean_object* x_12; lean_object* x_13;
 x_11 = lean_ctor_get(x_8, 1);
 lean_inc(x_11);
 lean_dec(x_8);
-x_12 = l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(x_1, x_6, x_11);
+x_12 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(x_1, x_6, x_11);
 x_13 = lean_ctor_get(x_12, 1);
 lean_inc(x_13);
 lean_dec(x_12);
@@ -3443,7 +3043,7 @@ _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_3 = l_Lean_SCC_scc___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__6___closed__2;
-x_4 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26(x_1, x_2, x_3);
+x_4 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(x_1, x_2, x_3);
 x_5 = lean_ctor_get(x_4, 1);
 lean_inc(x_5);
 lean_dec(x_4);
@@ -3454,7 +3054,7 @@ x_7 = l_List_reverse___rarg(x_6);
 return x_7;
 }
 }
-lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -3497,7 +3097,7 @@ return x_13;
 }
 }
 }
-lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__29(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -3518,7 +3118,7 @@ x_7 = lean_array_fget(x_3, x_2);
 x_8 = lean_unsigned_to_nat(0u);
 x_9 = lean_array_fset(x_3, x_2, x_8);
 x_10 = x_7;
-x_11 = l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(x_10, x_1, x_8);
+x_11 = l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(x_10, x_1, x_8);
 lean_dec(x_10);
 x_12 = lean_unsigned_to_nat(1u);
 x_13 = lean_nat_add(x_2, x_12);
@@ -3551,7 +3151,7 @@ goto _start;
 }
 }
 }
-lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__29(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__30(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; uint8_t x_5; 
@@ -3577,7 +3177,7 @@ x_12 = lean_mk_empty_array_with_capacity(x_11);
 lean_dec(x_11);
 x_13 = l_List_toArrayAux___main___rarg(x_10, x_12);
 x_14 = x_13;
-x_15 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(x_1, x_8, x_14);
+x_15 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__29(x_1, x_8, x_14);
 x_16 = x_15;
 x_17 = lean_unsigned_to_nat(1u);
 x_18 = lean_nat_add(x_2, x_17);
@@ -3603,7 +3203,7 @@ lean_dec(x_5);
 x_7 = l_List_toArrayAux___main___rarg(x_4, x_6);
 x_8 = x_7;
 x_9 = lean_unsigned_to_nat(0u);
-x_10 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__29(x_1, x_9, x_8);
+x_10 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__30(x_1, x_9, x_8);
 x_11 = x_10;
 return x_11;
 }
@@ -3673,11 +3273,11 @@ lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l___private_Lean_Util_SCC_1__getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_1, x_2);
+x_3 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__7(x_1, x_2);
 lean_dec(x_1);
 return x_3;
 }
@@ -3702,47 +3302,56 @@ lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l___private_Lean_Util_SCC_6__addSCCAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(x_1, x_2, x_3, x_4);
+x_5 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__22(x_1, x_2, x_3, x_4);
 lean_dec(x_1);
 return x_5;
 }
 }
-lean_object* l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l___private_Lean_Util_SCC_7__addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_1, x_2);
+x_3 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__21(x_1, x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24___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_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(x_1, x_2, x_3, x_4);
-lean_dec(x_1);
-return x_5;
-}
-}
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l___private_Lean_Util_SCC_8__sccAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(x_1, x_2, x_3);
+x_4 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__10(x_1, x_2, x_3);
 lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25___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_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__25(x_1, x_2, x_3, x_4);
+lean_dec(x_1);
+return x_5;
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__26(x_1, x_2, x_3);
+x_4 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__24(x_1, x_2, x_3);
+lean_dec(x_1);
+return x_4;
+}
+}
+lean_object* l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_List_forM___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(x_1, x_2, x_3);
 lean_dec(x_1);
 return x_4;
 }
@@ -3756,25 +3365,16 @@ lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__27(x_1, x_2, x_3);
+x_4 = l_Array_findMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(x_1, x_2, x_3);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__28(x_1, x_2, x_3);
-lean_dec(x_1);
-return x_4;
-}
-}
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__29___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -3784,6 +3384,15 @@ lean_dec(x_1);
 return x_4;
 }
 }
+lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__30___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___spec__30(x_1, x_2, x_3);
+lean_dec(x_1);
+return x_4;
+}
+}
 lean_object* l___private_Lean_Elab_PreDefinition_Main_0__Lean_Elab_partitionPreDefs___boxed(lean_object* x_1) {
 _start:
 {
diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c b/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c
index 3e12750acf..d3a37a603e 100644
--- a/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c
+++ b/stage0/stdlib/Lean/Elab/PreDefinition/Structural.c
@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_hasBadIndexDep_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_withBelowDict___spec__1___rarg___closed__2;
 extern lean_object* l_Lean_Meta_binductionOnSuffix;
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecOn___lambda__3___closed__3;
@@ -27,6 +26,7 @@ lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hy
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop_match__1(lean_object*, lean_object*);
 size_t l_USize_add(size_t, size_t);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_hasBadIndexDep_x3f___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*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_elimRecursion___lambda__2___closed__1;
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_withBelowDict___rarg___closed__2;
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
@@ -49,7 +49,6 @@ lean_object* l_Lean_Meta_withLetDecl___at___private_Lean_Elab_PreDefinition_Stru
 lean_object* l_Lean_Meta_isExprDefEq___at_Lean_Meta_isExprDefEqGuarded___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecOn___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_MessageData_ofList___closed__3;
-uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg(lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop_match__3(lean_object*);
@@ -62,7 +61,6 @@ lean_object* l_Lean_Meta_MatcherApp_addArg(lean_object*, lean_object*, lean_obje
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecOn___closed__2;
 extern lean_object* l_Std_HashMap_inhabited___closed__1;
 lean_object* l___private_Init_Data_Array_Basic_9__allDiffAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___spec__3___boxed(lean_object*, lean_object*);
-lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Meta_InferType_0__Lean_Meta_inferAppType___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_ensureNoRecFn___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_toBelowAux___closed__16;
@@ -98,6 +96,7 @@ lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_toBelow
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___spec__8___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_Expr_withAppAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___spec__3___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*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___closed__1;
 lean_object* l_Lean_MessageData_ofList(lean_object*);
 lean_object* l_Lean_Expr_getAppFn___main(lean_object*);
@@ -208,7 +207,6 @@ lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___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*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___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* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_elimRecursion___lambda__1___closed__1;
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_setEnv___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_elimRecursion___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_elimRecursion___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*);
 extern lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_processAssignmentFOApprox_loop___closed__3;
@@ -258,7 +256,6 @@ lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecO
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___spec__8___lambda__2___closed__2;
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_toBelowAux___lambda__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_toBelowAux___closed__4;
-size_t l_USize_mod(size_t, size_t);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecOn___lambda__3___closed__4;
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_withBelowDict(lean_object*);
@@ -274,7 +271,6 @@ lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_toBelow
 extern lean_object* l_Lean_Expr_FindImpl_initCache;
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___spec__11___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_hasBadIndexDep_x3f_match__4___rarg(lean_object*, lean_object*, lean_object*);
-size_t lean_ptr_addr(lean_object*);
 uint8_t l___private_Init_Data_Array_Basic_9__allDiffAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___spec__3(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___spec__3___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_hasBadParamDep_x3f___spec__2(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -313,7 +309,6 @@ lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_hasBadP
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_hasBadParamDep_x3f___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setMCtx___at___private_Lean_Meta_Basic_0__Lean_Meta_liftMkBindingM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___rarg___closed__16;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop(lean_object*, 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*);
 uint8_t l_Lean_Expr_isFVar(lean_object*);
@@ -344,7 +339,7 @@ lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_ensureN
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecOn___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_indentD(lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(lean_object*, size_t, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_withBelowDict___spec__1___rarg___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecOn___lambda__3___closed__5;
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
@@ -357,9 +352,11 @@ lean_object* l_Lean_addTrace___at_Lean_Meta_isLevelDefEq___spec__2(lean_object*,
 extern lean_object* l_Nat_Inhabited;
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop_match__2(lean_object*);
 lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
+uint8_t l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___lambda__1(lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_lambdaTelescopeImp___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop(lean_object*);
+lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_mkBRecOn___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withLetDeclImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_ensureNoRecFn___lambda__1___closed__2;
@@ -3385,7 +3382,7 @@ x_1 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Structural_
 x_2 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___spec__2___closed__2;
 x_3 = lean_unsigned_to_nat(111u);
 x_4 = lean_unsigned_to_nat(117u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -4274,7 +4271,7 @@ lean_dec(x_136);
 x_140 = lean_nat_add(x_4, x_54);
 lean_dec(x_4);
 lean_inc(x_140);
-x_141 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_140);
+x_141 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_140);
 x_142 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_142, 0, x_141);
 x_143 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___rarg___closed__2;
@@ -4557,7 +4554,7 @@ lean_dec(x_214);
 x_218 = lean_nat_add(x_4, x_54);
 lean_dec(x_4);
 lean_inc(x_218);
-x_219 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_218);
+x_219 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_218);
 x_220 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_220, 0, x_219);
 x_221 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___rarg___closed__2;
@@ -4848,7 +4845,7 @@ lean_dec(x_10);
 x_296 = lean_nat_add(x_4, x_54);
 lean_dec(x_4);
 lean_inc(x_296);
-x_297 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_296);
+x_297 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_296);
 x_298 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_298, 0, x_297);
 x_299 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___rarg___closed__2;
@@ -5086,7 +5083,7 @@ lean_dec(x_10);
 x_363 = lean_nat_add(x_4, x_54);
 lean_dec(x_4);
 lean_inc(x_363);
-x_364 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_363);
+x_364 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_363);
 x_365 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_365, 0, x_364);
 x_366 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_findRecArg_loop___rarg___closed__2;
@@ -5521,504 +5518,50 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Structural_
 return x_2;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
+uint8_t l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; size_t x_97; size_t x_98; lean_object* x_99; size_t x_100; uint8_t x_101; 
-x_97 = lean_ptr_addr(x_3);
-x_98 = x_2 == 0 ? 0 : x_97 % x_2;
-x_99 = lean_array_uget(x_4, x_98);
-x_100 = lean_ptr_addr(x_99);
-lean_dec(x_99);
-x_101 = x_100 == x_97;
-if (x_101 == 0)
-{
-lean_object* x_102; uint8_t x_103; 
-lean_inc(x_3);
-x_102 = lean_array_uset(x_4, x_98, x_3);
-x_103 = 0;
-x_5 = x_103;
-x_6 = x_102;
-goto block_96;
-}
-else
-{
-uint8_t x_104; 
-x_104 = 1;
-x_5 = x_104;
-x_6 = x_4;
-goto block_96;
-}
-block_96:
-{
-if (x_5 == 0)
-{
-uint8_t x_7; 
-x_7 = l_Lean_Expr_isConstOf(x_3, x_1);
-if (x_7 == 0)
-{
-switch (lean_obj_tag(x_3)) {
-case 5:
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-lean_dec(x_3);
-x_10 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(x_1, x_2, x_8, x_6);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-lean_dec(x_10);
-x_3 = x_9;
-x_4 = x_12;
-goto _start;
-}
-else
-{
-uint8_t x_14; 
-lean_dec(x_9);
-x_14 = !lean_is_exclusive(x_10);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_10, 0);
-lean_dec(x_15);
-x_16 = !lean_is_exclusive(x_11);
-if (x_16 == 0)
-{
-return x_10;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-x_17 = lean_ctor_get(x_11, 0);
-lean_inc(x_17);
-lean_dec(x_11);
-x_18 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_10, 0, x_18);
-return x_10;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_10, 1);
-lean_inc(x_19);
-lean_dec(x_10);
-x_20 = lean_ctor_get(x_11, 0);
-lean_inc(x_20);
-if (lean_is_exclusive(x_11)) {
- lean_ctor_release(x_11, 0);
- x_21 = x_11;
-} else {
- lean_dec_ref(x_11);
- x_21 = lean_box(0);
-}
-if (lean_is_scalar(x_21)) {
- x_22 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_22 = x_21;
-}
-lean_ctor_set(x_22, 0, x_20);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_22);
-lean_ctor_set(x_23, 1, x_19);
-return x_23;
-}
-}
-}
-case 6:
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = lean_ctor_get(x_3, 1);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_3, 2);
-lean_inc(x_25);
-lean_dec(x_3);
-x_26 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(x_1, x_2, x_24, x_6);
-x_27 = lean_ctor_get(x_26, 0);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; 
-x_28 = lean_ctor_get(x_26, 1);
-lean_inc(x_28);
-lean_dec(x_26);
-x_3 = x_25;
-x_4 = x_28;
-goto _start;
-}
-else
-{
-uint8_t x_30; 
-lean_dec(x_25);
-x_30 = !lean_is_exclusive(x_26);
-if (x_30 == 0)
-{
-lean_object* x_31; uint8_t x_32; 
-x_31 = lean_ctor_get(x_26, 0);
-lean_dec(x_31);
-x_32 = !lean_is_exclusive(x_27);
-if (x_32 == 0)
-{
-return x_26;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_27, 0);
-lean_inc(x_33);
-lean_dec(x_27);
-x_34 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_34, 0, x_33);
-lean_ctor_set(x_26, 0, x_34);
-return x_26;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_35 = lean_ctor_get(x_26, 1);
-lean_inc(x_35);
-lean_dec(x_26);
-x_36 = lean_ctor_get(x_27, 0);
-lean_inc(x_36);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- x_37 = x_27;
-} else {
- lean_dec_ref(x_27);
- x_37 = lean_box(0);
-}
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_38 = x_37;
-}
-lean_ctor_set(x_38, 0, x_36);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_35);
-return x_39;
-}
-}
-}
-case 7:
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_40 = lean_ctor_get(x_3, 1);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_3, 2);
-lean_inc(x_41);
-lean_dec(x_3);
-x_42 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(x_1, x_2, x_40, x_6);
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; 
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_3 = x_41;
-x_4 = x_44;
-goto _start;
-}
-else
-{
-uint8_t x_46; 
-lean_dec(x_41);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_42, 0);
-lean_dec(x_47);
-x_48 = !lean_is_exclusive(x_43);
-if (x_48 == 0)
-{
-return x_42;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; 
-x_49 = lean_ctor_get(x_43, 0);
-lean_inc(x_49);
-lean_dec(x_43);
-x_50 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_42, 0, x_50);
-return x_42;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_51 = lean_ctor_get(x_42, 1);
-lean_inc(x_51);
-lean_dec(x_42);
-x_52 = lean_ctor_get(x_43, 0);
-lean_inc(x_52);
-if (lean_is_exclusive(x_43)) {
- lean_ctor_release(x_43, 0);
- x_53 = x_43;
-} else {
- lean_dec_ref(x_43);
- x_53 = lean_box(0);
-}
-if (lean_is_scalar(x_53)) {
- x_54 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_54 = x_53;
-}
-lean_ctor_set(x_54, 0, x_52);
-x_55 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_51);
-return x_55;
-}
-}
-}
-case 8:
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_56 = lean_ctor_get(x_3, 1);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_3, 2);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_3, 3);
-lean_inc(x_58);
-lean_dec(x_3);
-x_59 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(x_1, x_2, x_56, x_6);
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_59, 1);
-lean_inc(x_61);
-lean_dec(x_59);
-x_62 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(x_1, x_2, x_57, x_61);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_62, 1);
-lean_inc(x_64);
-lean_dec(x_62);
-x_3 = x_58;
-x_4 = x_64;
-goto _start;
-}
-else
-{
-uint8_t x_66; 
-lean_dec(x_58);
-x_66 = !lean_is_exclusive(x_62);
-if (x_66 == 0)
-{
-lean_object* x_67; uint8_t x_68; 
-x_67 = lean_ctor_get(x_62, 0);
-lean_dec(x_67);
-x_68 = !lean_is_exclusive(x_63);
-if (x_68 == 0)
-{
-return x_62;
-}
-else
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_63, 0);
-lean_inc(x_69);
-lean_dec(x_63);
-x_70 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_62, 0, x_70);
-return x_62;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_71 = lean_ctor_get(x_62, 1);
-lean_inc(x_71);
-lean_dec(x_62);
-x_72 = lean_ctor_get(x_63, 0);
-lean_inc(x_72);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- x_73 = x_63;
-} else {
- lean_dec_ref(x_63);
- x_73 = lean_box(0);
-}
-if (lean_is_scalar(x_73)) {
- x_74 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_74 = x_73;
-}
-lean_ctor_set(x_74, 0, x_72);
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_71);
-return x_75;
-}
-}
-}
-else
-{
-uint8_t x_76; 
-lean_dec(x_58);
-lean_dec(x_57);
-x_76 = !lean_is_exclusive(x_59);
-if (x_76 == 0)
-{
-lean_object* x_77; uint8_t x_78; 
-x_77 = lean_ctor_get(x_59, 0);
-lean_dec(x_77);
-x_78 = !lean_is_exclusive(x_60);
-if (x_78 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_60, 0);
-lean_inc(x_79);
-lean_dec(x_60);
-x_80 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_59, 0, x_80);
-return x_59;
-}
-}
-else
-{
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_81 = lean_ctor_get(x_59, 1);
-lean_inc(x_81);
-lean_dec(x_59);
-x_82 = lean_ctor_get(x_60, 0);
-lean_inc(x_82);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- x_83 = x_60;
-} else {
- lean_dec_ref(x_60);
- x_83 = lean_box(0);
-}
-if (lean_is_scalar(x_83)) {
- x_84 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_84 = x_83;
-}
-lean_ctor_set(x_84, 0, x_82);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_81);
-return x_85;
-}
-}
-}
-case 10:
-{
-lean_object* x_86; 
-x_86 = lean_ctor_get(x_3, 1);
-lean_inc(x_86);
-lean_dec(x_3);
-x_3 = x_86;
-x_4 = x_6;
-goto _start;
-}
-case 11:
-{
-lean_object* x_88; 
-x_88 = lean_ctor_get(x_3, 2);
-lean_inc(x_88);
-lean_dec(x_3);
-x_3 = x_88;
-x_4 = x_6;
-goto _start;
-}
-default: 
-{
-lean_object* x_90; lean_object* x_91; 
-lean_dec(x_3);
-x_90 = lean_box(0);
-x_91 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_6);
-return x_91;
-}
-}
-}
-else
-{
-lean_object* x_92; lean_object* x_93; 
-x_92 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_92, 0, x_3);
-x_93 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_93, 0, x_92);
-lean_ctor_set(x_93, 1, x_6);
-return x_93;
-}
-}
-else
-{
-lean_object* x_94; lean_object* x_95; 
-lean_dec(x_3);
-x_94 = lean_box(0);
-x_95 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_95, 0, x_94);
-lean_ctor_set(x_95, 1, x_6);
-return x_95;
-}
-}
+uint8_t x_3; 
+x_3 = l_Lean_Expr_isConstOf(x_2, x_1);
+return x_3;
 }
 }
 uint8_t l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_3 = 8192;
-x_4 = l_Lean_Expr_FindImpl_initCache;
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(x_1, x_3, x_2, x_4);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-lean_dec(x_5);
-if (lean_obj_tag(x_6) == 0)
+lean_object* x_3; size_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_alloc_closure((void*)(l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___lambda__1___boxed), 2, 1);
+lean_closure_set(x_3, 0, x_1);
+x_4 = 8192;
+x_5 = l_Lean_Expr_FindImpl_initCache;
+x_6 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_3, x_4, x_2, x_5);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_7) == 0)
 {
-uint8_t x_7; 
-x_7 = 0;
-return x_7;
+uint8_t x_8; 
+x_8 = 0;
+return x_8;
 }
 else
 {
-uint8_t x_8; 
-lean_dec(x_6);
-x_8 = 1;
-return x_8;
+uint8_t x_9; 
+lean_dec(x_7);
+x_9 = 1;
+return x_9;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_5; lean_object* x_6; 
-x_5 = lean_unbox_usize(x_2);
+uint8_t x_3; lean_object* x_4; 
+x_3 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___lambda__1(x_1, x_2);
 lean_dec(x_2);
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___spec__1(x_1, x_5, x_3, x_4);
 lean_dec(x_1);
-return x_6;
+x_4 = lean_box(x_3);
+return x_4;
 }
 }
 lean_object* l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn___boxed(lean_object* x_1, lean_object* x_2) {
@@ -6026,7 +5569,6 @@ _start:
 {
 uint8_t x_3; lean_object* x_4; 
 x_3 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn(x_1, x_2);
-lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
@@ -6103,6 +5645,7 @@ _start:
 {
 uint8_t x_8; 
 lean_inc(x_2);
+lean_inc(x_1);
 x_8 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn(x_1, x_2);
 if (x_8 == 0)
 {
@@ -9737,7 +9280,7 @@ else
 {
 lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
 lean_inc(x_1);
-x_35 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_1);
+x_35 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_1);
 x_36 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_36, 0, x_35);
 x_37 = l_Array_umapMAux___main___at___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_replaceRecApps_loop___spec__8___lambda__2___closed__6;
@@ -10737,6 +10280,7 @@ x_21 = lean_ctor_get(x_11, 0);
 lean_inc(x_21);
 lean_dec(x_11);
 lean_inc(x_4);
+lean_inc(x_1);
 x_110 = l___private_Lean_Elab_PreDefinition_Structural_0__Lean_Elab_containsRecFn(x_1, x_4);
 if (x_110 == 0)
 {
diff --git a/stage0/stdlib/Lean/Elab/Quotation.c b/stage0/stdlib/Lean/Elab/Quotation.c
index ca9e2c9fa9..b312f8298c 100644
--- a/stage0/stdlib/Lean/Elab/Quotation.c
+++ b/stage0/stdlib/Lean/Elab/Quotation.c
@@ -25,6 +25,7 @@ lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_explode
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__2___closed__5;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___closed__4;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___closed__51;
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_toPreterm___closed__7;
 lean_object* l_Lean_Elab_Term_Quotation_stxQuot_expand___closed__21;
 extern lean_object* l_Lean_Expr_eq_x3f___closed__2;
@@ -231,13 +232,13 @@ lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compile
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_Quotation_elabfunBinderQuot(lean_object*);
 lean_object* l_Lean_Syntax_findAux___main(lean_object*, lean_object*);
+extern lean_object* l_Lean_setOptionFromString___closed__4;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getPatternVarsAux_match__1(lean_object*);
 lean_object* l_Lean_MessageData_toString(lean_object*, lean_object*);
 extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_301____closed__5;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_toPreterm___lambda__2___closed__4;
 extern lean_object* l_Lean_Elab_Term_State_inhabited___closed__1;
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
-lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15;
 extern lean_object* l_Lean_myMacro____x40_Lean_Util_Trace___hyg_45____closed__7;
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_toPreterm___closed__11;
 extern lean_object* l_Lean_numLitKind;
@@ -503,7 +504,6 @@ uint8_t l_Lean_Elab_Term_Quotation_isAntiquotSplice(lean_object*);
 lean_object* l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_getHeadInfo___lambda__4___closed__1;
 lean_object* lean_parse_expr(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Elab_Term_Lean_Elab_Term___instance__6___rarg___closed__1;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_List_mapM___main___at___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___spec__5___boxed(lean_object*, 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*);
 lean_object* l_Lean_resolveGlobalName___at_Lean_Elab_Term_resolveName___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1925,7 +1925,7 @@ x_1 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___
 x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___closed__2;
 x_3 = lean_unsigned_to_nat(103u);
 x_4 = lean_unsigned_to_nat(20u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -6455,7 +6455,7 @@ x_1 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___
 x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_explodeHeadPat___closed__1;
 x_3 = lean_unsigned_to_nat(225u);
 x_4 = lean_unsigned_to_nat(7u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -7949,34 +7949,24 @@ return x_4;
 static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__11() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Bool_HasRepr___closed__2;
-x_3 = lean_name_mk_string(x_1, x_2);
-return x_3;
-}
-}
-static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12() {
-_start:
-{
 lean_object* x_1; 
 x_1 = lean_mk_string("then");
 return x_1;
 }
 }
-static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13() {
+static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_SourceInfo_inhabited___closed__1;
-x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
+x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__11;
 x_3 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14() {
+static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13() {
 _start:
 {
 lean_object* x_1; 
@@ -7984,12 +7974,12 @@ x_1 = lean_mk_string("else");
 return x_1;
 }
 }
-static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15() {
+static lean_object* _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_SourceInfo_inhabited___closed__1;
-x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
+x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
 x_3 = lean_alloc_ctor(2, 2, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_2);
@@ -8048,7 +8038,7 @@ x_40 = lean_array_push(x_38, x_39);
 x_41 = lean_array_push(x_24, x_5);
 x_42 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__8;
 x_43 = lean_array_push(x_41, x_42);
-x_44 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__11;
+x_44 = l_Lean_setOptionFromString___closed__4;
 x_45 = l_Lean_addMacroScope(x_18, x_44, x_14);
 x_46 = l_Lean_boolToExpr___lambda__1___closed__5;
 lean_inc(x_1);
@@ -8071,10 +8061,10 @@ lean_ctor_set(x_53, 0, x_52);
 lean_ctor_set(x_53, 1, x_51);
 x_54 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__5;
 x_55 = lean_array_push(x_54, x_53);
-x_56 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
+x_56 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
 x_57 = lean_array_push(x_55, x_56);
 x_58 = lean_array_push(x_57, x_3);
-x_59 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15;
+x_59 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
 x_60 = lean_array_push(x_58, x_59);
 x_61 = lean_array_push(x_60, x_4);
 x_62 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__2;
@@ -8133,7 +8123,7 @@ x_90 = lean_array_push(x_88, x_89);
 x_91 = lean_array_push(x_74, x_5);
 x_92 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__8;
 x_93 = lean_array_push(x_91, x_92);
-x_94 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__11;
+x_94 = l_Lean_setOptionFromString___closed__4;
 x_95 = l_Lean_addMacroScope(x_67, x_94, x_14);
 x_96 = l_Lean_boolToExpr___lambda__1___closed__5;
 lean_inc(x_1);
@@ -8156,10 +8146,10 @@ lean_ctor_set(x_103, 0, x_102);
 lean_ctor_set(x_103, 1, x_101);
 x_104 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__5;
 x_105 = lean_array_push(x_104, x_103);
-x_106 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13;
+x_106 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__12;
 x_107 = lean_array_push(x_105, x_106);
 x_108 = lean_array_push(x_107, x_3);
-x_109 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15;
+x_109 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14;
 x_110 = lean_array_push(x_108, x_109);
 x_111 = lean_array_push(x_110, x_4);
 x_112 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__2;
@@ -9856,7 +9846,7 @@ x_1 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___
 x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___closed__4;
 x_3 = lean_unsigned_to_nat(254u);
 x_4 = lean_unsigned_to_nat(10u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -15908,7 +15898,7 @@ x_1 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___
 x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_toPreterm___closed__6;
 x_3 = lean_unsigned_to_nat(334u);
 x_4 = lean_unsigned_to_nat(11u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -15921,7 +15911,7 @@ x_1 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_quoteSyntax___
 x_2 = l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_toPreterm___closed__6;
 x_3 = lean_unsigned_to_nat(333u);
 x_4 = lean_unsigned_to_nat(14u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -22634,8 +22624,6 @@ l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___la
 lean_mark_persistent(l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__13);
 l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14 = _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14();
 lean_mark_persistent(l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__14);
-l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15 = _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15();
-lean_mark_persistent(l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__1___closed__15);
 l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__2___closed__1 = _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__2___closed__1();
 lean_mark_persistent(l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__2___closed__1);
 l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__2___closed__2 = _init_l___private_Lean_Elab_Quotation_0__Lean_Elab_Term_Quotation_compileStxMatch___lambda__2___closed__2();
diff --git a/stage0/stdlib/Lean/Elab/StrategyAttrs.c b/stage0/stdlib/Lean/Elab/StrategyAttrs.c
index 10ad082a33..0fe405fba6 100644
--- a/stage0/stdlib/Lean/Elab/StrategyAttrs.c
+++ b/stage0/stdlib/Lean/Elab/StrategyAttrs.c
@@ -13,8 +13,6 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2___boxed(lean_object*, lean_object*);
 lean_object* lean_nat_div(lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_getModuleEntries___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____closed__10;
@@ -25,6 +23,7 @@ uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
 uint8_t l_Lean_ElaboratorStrategy_inhabited;
 extern lean_object* l_Lean_registerInternalExceptionId___closed__2;
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_registerExt___rarg(lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
@@ -41,7 +40,6 @@ lean_object* l_Lean_registerEnumAttributes___at_Lean_initFn____x40_Lean_Elab_Str
 lean_object* l_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____closed__3;
 lean_object* l_Lean_elaboratorStrategyAttrs;
 lean_object* l_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____closed__18;
-lean_object* l_Std_RBNode_find___main___at_Lean_getElaboratorStrategy___spec__2___boxed(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Environment_8__persistentEnvExtensionsRef;
 lean_object* l_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -64,7 +62,7 @@ lean_object* l_List_map___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs__
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__1___lambda__2(lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_getElaboratorStrategy___spec__2(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_getElaboratorStrategy___spec__2___boxed(lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__4___closed__1;
 lean_object* l_Array_qsortAux___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__3(lean_object*, lean_object*, lean_object*);
@@ -81,7 +79,9 @@ lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_ob
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
 extern lean_object* l_Lean_EnumAttributes_Inhabited___closed__1;
 lean_object* l_List_map___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__7___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____closed__11;
+lean_object* l_Std_RBNode_find___at_Lean_getElaboratorStrategy___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__1___lambda__2___boxed(lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerEnumAttributes___rarg___closed__1;
@@ -119,7 +119,7 @@ x_1 = 1;
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -133,7 +133,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -948,7 +948,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -1323,11 +1323,11 @@ x_6 = l_Lean_registerEnumAttributes___at_Lean_initFn____x40_Lean_Elab_StrategyAt
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_initFn____x40_Lean_Elab_StrategyAttrs___hyg_14____spec__2(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -1420,7 +1420,7 @@ lean_dec(x_1);
 return x_8;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getElaboratorStrategy___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_getElaboratorStrategy___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -1554,7 +1554,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at_Lean_getElaboratorStrategy___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at_Lean_getElaboratorStrategy___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
@@ -1628,11 +1628,11 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getElaboratorStrategy___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_getElaboratorStrategy___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_getElaboratorStrategy___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_getElaboratorStrategy___spec__2(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Elab/StructInst.c b/stage0/stdlib/Lean/Elab/StructInst.c
index c806a0dc16..db99a663a3 100644
--- a/stage0/stdlib/Lean/Elab/StructInst.c
+++ b/stage0/stdlib/Lean/Elab/StructInst.c
@@ -17,12 +17,12 @@ lean_object* l_List_reverse___rarg(lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandStruct___spec__11(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStructInstAux___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_Term_StructInst_Struct_modifyFields(lean_object*, lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Field_toSyntax_match__2(lean_object*);
 lean_object* l_Std_HashMap_toList___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandStruct___spec__6(lean_object*);
 lean_object* l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_step___spec__1___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabModifyOp___closed__3;
 lean_object* l_List_foldlM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_mkFieldMap___spec__10___closed__4;
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 extern lean_object* l_Lean_fieldIdxKind;
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_mkDefaultValueAux_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
@@ -61,7 +61,6 @@ lean_object* l___regBuiltin_Lean_Elab_Term_StructInst_expandStructInstExpectedTy
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_reduceProjOf_x3f_match__1(lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_FieldLHS_toSyntax_match__1(lean_object*);
 uint8_t l_Lean_Elab_Term_StructInst_Struct_allDefault(lean_object*);
-uint8_t l_USize_decEq(size_t, size_t);
 lean_object* l_Lean_Elab_Term_StructInst_FieldVal_toSyntax_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Lean_Format_joinSep___main___at_Lean_Elab_Term_StructInst_formatField___spec__1(lean_object*, lean_object*);
@@ -142,6 +141,7 @@ lean_object* l_Lean_Elab_Term_StructInst_expandStructInstExpectedType(lean_objec
 lean_object* l_List_find_x3f___main___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStructInstAux___closed__4;
 lean_object* l_Lean_Elab_Term_StructInst_Struct_setFields(lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_Std_HashMap_toList___rarg(lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabModifyOp___closed__18;
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_groupFields___lambda__1(lean_object*);
@@ -199,6 +199,7 @@ lean_object* l_Lean_Elab_Term_ensureHasType(lean_object*, lean_object*, lean_obj
 lean_object* l_Lean_Meta_mkForallFVars___at___private_Lean_Meta_InferType_0__Lean_Meta_inferLambdaType___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_collectStructNames(lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___lambda__1___boxed(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Term_throwTypeMismatchError___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Field_isSimple___rarg___boxed(lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Struct_modifyFieldsM_match__1___rarg(lean_object*, lean_object*);
@@ -254,7 +255,6 @@ lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabM
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStruct_match__9___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldlM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStruct___spec__1___closed__3;
 extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_301____closed__5;
-lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabModifyOp___closed__8;
 lean_object* l_List_map___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields___spec__1(lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
@@ -403,6 +403,7 @@ lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_lo
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getForallBody(lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStruct_match__2___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_SynthInstance_getInstances___lambda__1___closed__8;
+lean_object* l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(lean_object*, lean_object*);
 lean_object* l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields___spec__2___closed__4;
 lean_object* l_List_head_x21___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandStruct___spec__3___boxed(lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_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*, lean_object*);
@@ -466,12 +467,12 @@ lean_object* l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab
 lean_object* l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields___spec__2___closed__5;
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getForallBody_match__1(lean_object*);
 lean_object* l_Lean_mkAtomFrom(lean_object*, lean_object*);
-size_t l_USize_mod(size_t, size_t);
 lean_object* l_Lean_Elab_Term_StructInst_FieldLHS_inhabited;
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandNumLitFields(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Struct_fields_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_List_foldlM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStruct___spec__1___closed__1;
 lean_object* l_Lean_ConstantInfo_lparams(lean_object*);
+uint8_t l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___lambda__1(lean_object*);
 lean_object* l_Array_umapMAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_HasRepr___closed__1;
 lean_object* l_Lean_Elab_Term_StructInst_findField_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -487,7 +488,6 @@ lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabM
 extern lean_object* l_Lean_Meta_substCore___lambda__13___closed__25;
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_step_match__1(lean_object*);
 extern lean_object* l_Lean_Syntax_inhabited;
-size_t lean_ptr_addr(lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStructInstAux___closed__2;
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_isModifyOp_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Field_toSyntax_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -572,7 +572,6 @@ lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_findDefaultMissing_x3f___
 lean_object* l_Lean_Elab_Term_StructInst_Struct_hasToString___closed__1;
 lean_object* l_Lean_Elab_Term_StructInst_Struct_allDefault_match__3(lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_isModifyOp_x3f___spec__1___closed__4;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_propagateExpectedType_match__2(lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields_match__2(lean_object*);
@@ -633,6 +632,7 @@ lean_object* l_Array_foldlStepMAux___main___at___private_Lean_Elab_StructInst_0_
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandStruct___spec__4(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_getFieldName_match__1(lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Field_hasToString___closed__1;
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_throwFailedToElabField___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_toFieldLHS(lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_mkFieldMap___spec__1___boxed(lean_object*, lean_object*);
@@ -650,6 +650,7 @@ lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_addMi
 lean_object* l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_mkStructView___spec__3(lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_FieldLHS_hasFormat_match__1(lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__3;
 lean_object* l_Lean_Elab_Term_StructInst_formatStruct___closed__2;
 lean_object* l_Lean_Elab_Term_StructInst_trySynthStructInstance_x3f___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_StructInst_Field_inhabited___closed__1;
@@ -665,7 +666,6 @@ lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expan
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_isSimpleField_x3f___boxed(lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getFieldIdx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_groupFields_match__2___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Struct_source_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_StructInst_Field_hasFormat;
 uint8_t l_Lean_Elab_Term_StructInst_DefaultFields_State_progress___default;
@@ -715,7 +715,6 @@ lean_object* l_Lean_findField_x3f___main(lean_object*, lean_object*, lean_object
 lean_object* l_List_foldlM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_elabStruct___spec__1___closed__4;
 extern lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_tryCoe___closed__3;
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandCompositeFields_match__1(lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(size_t, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Term_StructInst_DefaultFields_propagateLoop___spec__2(lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields_match__4___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_groupFields___lambda__3___closed__2;
@@ -1796,7 +1795,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSource___closed__5;
 x_3 = lean_unsigned_to_nat(76u);
 x_4 = lean_unsigned_to_nat(17u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -4664,7 +4663,7 @@ lean_object* x_4; lean_object* x_5;
 x_4 = lean_ctor_get(x_1, 1);
 lean_inc(x_4);
 lean_dec(x_1);
-x_5 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_4);
+x_5 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_4);
 return x_5;
 }
 default: 
@@ -5285,7 +5284,7 @@ lean_object* x_8; lean_object* x_9;
 x_8 = lean_ctor_get(x_5, 1);
 lean_inc(x_8);
 lean_dec(x_5);
-x_9 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_8);
+x_9 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_8);
 return x_9;
 }
 default: 
@@ -5337,7 +5336,7 @@ lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25;
 x_22 = lean_ctor_get(x_16, 1);
 lean_inc(x_22);
 lean_dec(x_16);
-x_23 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_22);
+x_23 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_22);
 x_24 = lean_alloc_ctor(4, 2, 0);
 lean_ctor_set(x_24, 0, x_23);
 lean_ctor_set(x_24, 1, x_2);
@@ -5648,7 +5647,7 @@ lean_inc(x_3);
 lean_dec(x_1);
 x_4 = l_List_map___main___at_Lean_Elab_Term_StructInst_formatStruct___spec__1(x_2);
 x_5 = l_Lean_formatKVMap___closed__1;
-x_6 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_6__toStringAux___main___spec__1(x_4, x_5);
+x_6 = l_Lean_Format_joinSep___main___at___private_Lean_Data_Trie_0__Lean_Parser_Trie_toStringAux___spec__1(x_4, x_5);
 lean_dec(x_4);
 switch (lean_obj_tag(x_3)) {
 case 0:
@@ -5963,7 +5962,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l_Lean_Elab_Term_StructInst_FieldVal_toSyntax___closed__1;
 x_3 = lean_unsigned_to_nat(255u);
 x_4 = lean_unsigned_to_nat(23u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -6095,7 +6094,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l_Lean_Elab_Term_StructInst_Field_toSyntax___closed__1;
 x_3 = lean_unsigned_to_nat(266u);
 x_4 = lean_unsigned_to_nat(9u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -8043,7 +8042,7 @@ lean_dec(x_34);
 lean_dec(x_33);
 lean_dec(x_14);
 lean_dec(x_13);
-x_51 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_45);
+x_51 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_45);
 x_52 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_52, 0, x_51);
 x_53 = l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandNumLitFields___spec__1___closed__2;
@@ -8157,7 +8156,7 @@ lean_dec(x_34);
 lean_dec(x_33);
 lean_dec(x_14);
 lean_dec(x_13);
-x_79 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_72);
+x_79 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_72);
 x_80 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_80, 0, x_79);
 x_81 = l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandNumLitFields___spec__1___closed__2;
@@ -8293,7 +8292,7 @@ lean_dec(x_34);
 lean_dec(x_33);
 lean_dec(x_14);
 lean_dec(x_13);
-x_110 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_102);
+x_110 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_102);
 x_111 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_111, 0, x_110);
 x_112 = l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandNumLitFields___spec__1___closed__2;
@@ -8451,7 +8450,7 @@ lean_dec(x_128);
 lean_dec(x_127);
 lean_dec(x_14);
 lean_dec(x_13);
-x_146 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_137);
+x_146 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_137);
 x_147 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_147, 0, x_146);
 x_148 = l_List_mapM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandNumLitFields___spec__1___closed__2;
@@ -8971,7 +8970,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l_List_map___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_expandParentFields___spec__1___closed__1;
 x_3 = lean_unsigned_to_nat(345u);
 x_4 = lean_unsigned_to_nat(32u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -10129,7 +10128,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l_List_foldlM___main___at___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_mkFieldMap___spec__10___closed__1;
 x_3 = lean_unsigned_to_nat(363u);
 x_4 = lean_unsigned_to_nat(9u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -20767,7 +20766,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l_Lean_Elab_Term_StructInst_DefaultFields_findDefaultMissing_x3f___lambda__1___closed__1;
 x_3 = lean_unsigned_to_nat(598u);
 x_4 = lean_unsigned_to_nat(20u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -21002,7 +21001,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l_Lean_Elab_Term_StructInst_DefaultFields_getFieldName___closed__1;
 x_3 = lean_unsigned_to_nat(606u);
 x_4 = lean_unsigned_to_nat(7u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -23175,484 +23174,23 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_tryTo
 return x_2;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(size_t x_1, lean_object* x_2, lean_object* x_3) {
+uint8_t l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___lambda__1(lean_object* x_1) {
 _start:
 {
-uint8_t x_4; lean_object* x_5; size_t x_99; size_t x_100; lean_object* x_101; size_t x_102; uint8_t x_103; 
-x_99 = lean_ptr_addr(x_2);
-x_100 = x_1 == 0 ? 0 : x_99 % x_1;
-x_101 = lean_array_uget(x_3, x_100);
-x_102 = lean_ptr_addr(x_101);
-lean_dec(x_101);
-x_103 = x_102 == x_99;
-if (x_103 == 0)
+lean_object* x_2; 
+x_2 = l_Lean_Elab_Term_StructInst_defaultMissing_x3f(x_1);
+if (lean_obj_tag(x_2) == 0)
 {
-lean_object* x_104; uint8_t x_105; 
-lean_inc(x_2);
-x_104 = lean_array_uset(x_3, x_100, x_2);
-x_105 = 0;
-x_4 = x_105;
-x_5 = x_104;
-goto block_98;
+uint8_t x_3; 
+x_3 = 0;
+return x_3;
 }
 else
 {
-uint8_t x_106; 
-x_106 = 1;
-x_4 = x_106;
-x_5 = x_3;
-goto block_98;
-}
-block_98:
-{
-if (x_4 == 0)
-{
-lean_object* x_6; 
-x_6 = l_Lean_Elab_Term_StructInst_defaultMissing_x3f(x_2);
-if (lean_obj_tag(x_6) == 0)
-{
-switch (lean_obj_tag(x_2)) {
-case 5:
-{
-lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
-x_7 = lean_ctor_get(x_2, 0);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_2, 1);
-lean_inc(x_8);
+uint8_t x_4; 
 lean_dec(x_2);
-x_9 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_1, x_7, x_5);
-x_10 = lean_ctor_get(x_9, 0);
-lean_inc(x_10);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_object* x_11; 
-x_11 = lean_ctor_get(x_9, 1);
-lean_inc(x_11);
-lean_dec(x_9);
-x_2 = x_8;
-x_3 = x_11;
-goto _start;
-}
-else
-{
-uint8_t x_13; 
-lean_dec(x_8);
-x_13 = !lean_is_exclusive(x_9);
-if (x_13 == 0)
-{
-lean_object* x_14; uint8_t x_15; 
-x_14 = lean_ctor_get(x_9, 0);
-lean_dec(x_14);
-x_15 = !lean_is_exclusive(x_10);
-if (x_15 == 0)
-{
-return x_9;
-}
-else
-{
-lean_object* x_16; lean_object* x_17; 
-x_16 = lean_ctor_get(x_10, 0);
-lean_inc(x_16);
-lean_dec(x_10);
-x_17 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_17, 0, x_16);
-lean_ctor_set(x_9, 0, x_17);
-return x_9;
-}
-}
-else
-{
-lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_18 = lean_ctor_get(x_9, 1);
-lean_inc(x_18);
-lean_dec(x_9);
-x_19 = lean_ctor_get(x_10, 0);
-lean_inc(x_19);
-if (lean_is_exclusive(x_10)) {
- lean_ctor_release(x_10, 0);
- x_20 = x_10;
-} else {
- lean_dec_ref(x_10);
- x_20 = lean_box(0);
-}
-if (lean_is_scalar(x_20)) {
- x_21 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_21 = x_20;
-}
-lean_ctor_set(x_21, 0, x_19);
-x_22 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_22, 0, x_21);
-lean_ctor_set(x_22, 1, x_18);
-return x_22;
-}
-}
-}
-case 6:
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
-x_23 = lean_ctor_get(x_2, 1);
-lean_inc(x_23);
-x_24 = lean_ctor_get(x_2, 2);
-lean_inc(x_24);
-lean_dec(x_2);
-x_25 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_1, x_23, x_5);
-x_26 = lean_ctor_get(x_25, 0);
-lean_inc(x_26);
-if (lean_obj_tag(x_26) == 0)
-{
-lean_object* x_27; 
-x_27 = lean_ctor_get(x_25, 1);
-lean_inc(x_27);
-lean_dec(x_25);
-x_2 = x_24;
-x_3 = x_27;
-goto _start;
-}
-else
-{
-uint8_t x_29; 
-lean_dec(x_24);
-x_29 = !lean_is_exclusive(x_25);
-if (x_29 == 0)
-{
-lean_object* x_30; uint8_t x_31; 
-x_30 = lean_ctor_get(x_25, 0);
-lean_dec(x_30);
-x_31 = !lean_is_exclusive(x_26);
-if (x_31 == 0)
-{
-return x_25;
-}
-else
-{
-lean_object* x_32; lean_object* x_33; 
-x_32 = lean_ctor_get(x_26, 0);
-lean_inc(x_32);
-lean_dec(x_26);
-x_33 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_25, 0, x_33);
-return x_25;
-}
-}
-else
-{
-lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; 
-x_34 = lean_ctor_get(x_25, 1);
-lean_inc(x_34);
-lean_dec(x_25);
-x_35 = lean_ctor_get(x_26, 0);
-lean_inc(x_35);
-if (lean_is_exclusive(x_26)) {
- lean_ctor_release(x_26, 0);
- x_36 = x_26;
-} else {
- lean_dec_ref(x_26);
- x_36 = lean_box(0);
-}
-if (lean_is_scalar(x_36)) {
- x_37 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_37 = x_36;
-}
-lean_ctor_set(x_37, 0, x_35);
-x_38 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_38, 0, x_37);
-lean_ctor_set(x_38, 1, x_34);
-return x_38;
-}
-}
-}
-case 7:
-{
-lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
-x_39 = lean_ctor_get(x_2, 1);
-lean_inc(x_39);
-x_40 = lean_ctor_get(x_2, 2);
-lean_inc(x_40);
-lean_dec(x_2);
-x_41 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_1, x_39, x_5);
-x_42 = lean_ctor_get(x_41, 0);
-lean_inc(x_42);
-if (lean_obj_tag(x_42) == 0)
-{
-lean_object* x_43; 
-x_43 = lean_ctor_get(x_41, 1);
-lean_inc(x_43);
-lean_dec(x_41);
-x_2 = x_40;
-x_3 = x_43;
-goto _start;
-}
-else
-{
-uint8_t x_45; 
-lean_dec(x_40);
-x_45 = !lean_is_exclusive(x_41);
-if (x_45 == 0)
-{
-lean_object* x_46; uint8_t x_47; 
-x_46 = lean_ctor_get(x_41, 0);
-lean_dec(x_46);
-x_47 = !lean_is_exclusive(x_42);
-if (x_47 == 0)
-{
-return x_41;
-}
-else
-{
-lean_object* x_48; lean_object* x_49; 
-x_48 = lean_ctor_get(x_42, 0);
-lean_inc(x_48);
-lean_dec(x_42);
-x_49 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_49, 0, x_48);
-lean_ctor_set(x_41, 0, x_49);
-return x_41;
-}
-}
-else
-{
-lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; 
-x_50 = lean_ctor_get(x_41, 1);
-lean_inc(x_50);
-lean_dec(x_41);
-x_51 = lean_ctor_get(x_42, 0);
-lean_inc(x_51);
-if (lean_is_exclusive(x_42)) {
- lean_ctor_release(x_42, 0);
- x_52 = x_42;
-} else {
- lean_dec_ref(x_42);
- x_52 = lean_box(0);
-}
-if (lean_is_scalar(x_52)) {
- x_53 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_53 = x_52;
-}
-lean_ctor_set(x_53, 0, x_51);
-x_54 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_54, 0, x_53);
-lean_ctor_set(x_54, 1, x_50);
-return x_54;
-}
-}
-}
-case 8:
-{
-lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
-x_55 = lean_ctor_get(x_2, 1);
-lean_inc(x_55);
-x_56 = lean_ctor_get(x_2, 2);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_2, 3);
-lean_inc(x_57);
-lean_dec(x_2);
-x_58 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_1, x_55, x_5);
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-if (lean_obj_tag(x_59) == 0)
-{
-lean_object* x_60; lean_object* x_61; lean_object* x_62; 
-x_60 = lean_ctor_get(x_58, 1);
-lean_inc(x_60);
-lean_dec(x_58);
-x_61 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_1, x_56, x_60);
-x_62 = lean_ctor_get(x_61, 0);
-lean_inc(x_62);
-if (lean_obj_tag(x_62) == 0)
-{
-lean_object* x_63; 
-x_63 = lean_ctor_get(x_61, 1);
-lean_inc(x_63);
-lean_dec(x_61);
-x_2 = x_57;
-x_3 = x_63;
-goto _start;
-}
-else
-{
-uint8_t x_65; 
-lean_dec(x_57);
-x_65 = !lean_is_exclusive(x_61);
-if (x_65 == 0)
-{
-lean_object* x_66; uint8_t x_67; 
-x_66 = lean_ctor_get(x_61, 0);
-lean_dec(x_66);
-x_67 = !lean_is_exclusive(x_62);
-if (x_67 == 0)
-{
-return x_61;
-}
-else
-{
-lean_object* x_68; lean_object* x_69; 
-x_68 = lean_ctor_get(x_62, 0);
-lean_inc(x_68);
-lean_dec(x_62);
-x_69 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_69, 0, x_68);
-lean_ctor_set(x_61, 0, x_69);
-return x_61;
-}
-}
-else
-{
-lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; 
-x_70 = lean_ctor_get(x_61, 1);
-lean_inc(x_70);
-lean_dec(x_61);
-x_71 = lean_ctor_get(x_62, 0);
-lean_inc(x_71);
-if (lean_is_exclusive(x_62)) {
- lean_ctor_release(x_62, 0);
- x_72 = x_62;
-} else {
- lean_dec_ref(x_62);
- x_72 = lean_box(0);
-}
-if (lean_is_scalar(x_72)) {
- x_73 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_73 = x_72;
-}
-lean_ctor_set(x_73, 0, x_71);
-x_74 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_74, 0, x_73);
-lean_ctor_set(x_74, 1, x_70);
-return x_74;
-}
-}
-}
-else
-{
-uint8_t x_75; 
-lean_dec(x_57);
-lean_dec(x_56);
-x_75 = !lean_is_exclusive(x_58);
-if (x_75 == 0)
-{
-lean_object* x_76; uint8_t x_77; 
-x_76 = lean_ctor_get(x_58, 0);
-lean_dec(x_76);
-x_77 = !lean_is_exclusive(x_59);
-if (x_77 == 0)
-{
-return x_58;
-}
-else
-{
-lean_object* x_78; lean_object* x_79; 
-x_78 = lean_ctor_get(x_59, 0);
-lean_inc(x_78);
-lean_dec(x_59);
-x_79 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_79, 0, x_78);
-lean_ctor_set(x_58, 0, x_79);
-return x_58;
-}
-}
-else
-{
-lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_80 = lean_ctor_get(x_58, 1);
-lean_inc(x_80);
-lean_dec(x_58);
-x_81 = lean_ctor_get(x_59, 0);
-lean_inc(x_81);
-if (lean_is_exclusive(x_59)) {
- lean_ctor_release(x_59, 0);
- x_82 = x_59;
-} else {
- lean_dec_ref(x_59);
- x_82 = lean_box(0);
-}
-if (lean_is_scalar(x_82)) {
- x_83 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_83 = x_82;
-}
-lean_ctor_set(x_83, 0, x_81);
-x_84 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_84, 0, x_83);
-lean_ctor_set(x_84, 1, x_80);
-return x_84;
-}
-}
-}
-case 10:
-{
-lean_object* x_85; 
-x_85 = lean_ctor_get(x_2, 1);
-lean_inc(x_85);
-lean_dec(x_2);
-x_2 = x_85;
-x_3 = x_5;
-goto _start;
-}
-case 11:
-{
-lean_object* x_87; 
-x_87 = lean_ctor_get(x_2, 2);
-lean_inc(x_87);
-lean_dec(x_2);
-x_2 = x_87;
-x_3 = x_5;
-goto _start;
-}
-default: 
-{
-lean_object* x_89; lean_object* x_90; 
-lean_dec(x_2);
-x_89 = lean_box(0);
-x_90 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_90, 0, x_89);
-lean_ctor_set(x_90, 1, x_5);
-return x_90;
-}
-}
-}
-else
-{
-uint8_t x_91; 
-x_91 = !lean_is_exclusive(x_6);
-if (x_91 == 0)
-{
-lean_object* x_92; lean_object* x_93; 
-x_92 = lean_ctor_get(x_6, 0);
-lean_dec(x_92);
-lean_ctor_set(x_6, 0, x_2);
-x_93 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_93, 0, x_6);
-lean_ctor_set(x_93, 1, x_5);
-return x_93;
-}
-else
-{
-lean_object* x_94; lean_object* x_95; 
-lean_dec(x_6);
-x_94 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_94, 0, x_2);
-x_95 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_95, 0, x_94);
-lean_ctor_set(x_95, 1, x_5);
-return x_95;
-}
-}
-}
-else
-{
-lean_object* x_96; lean_object* x_97; 
-lean_dec(x_2);
-x_96 = lean_box(0);
-x_97 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_97, 0, x_96);
-lean_ctor_set(x_97, 1, x_5);
-return x_97;
-}
+x_4 = 1;
+return x_4;
 }
 }
 }
@@ -23674,6 +23212,14 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
+static lean_object* _init_l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__3() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_alloc_closure((void*)(l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___lambda__1___boxed), 1, 0);
+return x_1;
+}
+}
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) {
 _start:
 {
@@ -23807,88 +23353,89 @@ lean_inc(x_2);
 x_51 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_2, x_50, x_10, x_11, x_12, x_13, x_48);
 if (lean_obj_tag(x_51) == 0)
 {
-lean_object* x_52; lean_object* x_53; size_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; 
+lean_object* x_52; lean_object* x_53; size_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; 
 x_52 = lean_ctor_get(x_51, 0);
 lean_inc(x_52);
 x_53 = lean_ctor_get(x_51, 1);
 lean_inc(x_53);
 lean_dec(x_51);
 x_54 = 8192;
-x_55 = l_Lean_Expr_FindImpl_initCache;
+x_55 = l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__3;
+x_56 = l_Lean_Expr_FindImpl_initCache;
 lean_inc(x_52);
-x_56 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_54, x_52, x_55);
-x_57 = lean_ctor_get(x_56, 0);
-lean_inc(x_57);
-lean_dec(x_56);
-if (lean_obj_tag(x_57) == 0)
+x_57 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_55, x_54, x_52, x_56);
+x_58 = lean_ctor_get(x_57, 0);
+lean_inc(x_58);
+lean_dec(x_57);
+if (lean_obj_tag(x_58) == 0)
 {
-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_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
 lean_dec(x_38);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_2);
-x_58 = l_Lean_Elab_Term_getMVarDecl(x_5, x_8, x_9, x_10, x_11, x_12, x_13, x_53);
-x_59 = lean_ctor_get(x_58, 0);
-lean_inc(x_59);
-x_60 = lean_ctor_get(x_58, 1);
+x_59 = l_Lean_Elab_Term_getMVarDecl(x_5, x_8, x_9, x_10, x_11, x_12, x_13, x_53);
+x_60 = lean_ctor_get(x_59, 0);
 lean_inc(x_60);
-lean_dec(x_58);
-x_61 = lean_ctor_get(x_59, 2);
+x_61 = lean_ctor_get(x_59, 1);
 lean_inc(x_61);
 lean_dec(x_59);
-lean_ctor_set(x_40, 0, x_61);
-x_62 = lean_box(0);
+x_62 = lean_ctor_get(x_60, 2);
+lean_inc(x_62);
+lean_dec(x_60);
+lean_ctor_set(x_40, 0, x_62);
+x_63 = lean_box(0);
 lean_inc(x_13);
 lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
-x_63 = l_Lean_Elab_Term_ensureHasType(x_40, x_52, x_62, x_8, x_9, x_10, x_11, x_12, x_13, x_60);
-if (lean_obj_tag(x_63) == 0)
+x_64 = l_Lean_Elab_Term_ensureHasType(x_40, x_52, x_63, x_8, x_9, x_10, x_11, x_12, x_13, x_61);
+if (lean_obj_tag(x_64) == 0)
 {
-lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_64 = lean_ctor_get(x_63, 0);
-lean_inc(x_64);
-x_65 = lean_ctor_get(x_63, 1);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; 
+x_65 = lean_ctor_get(x_64, 0);
 lean_inc(x_65);
-lean_dec(x_63);
-x_66 = l_Lean_Meta_assignExprMVar___at_Lean_Elab_Term_synthesizeInstMVarCore___spec__2(x_5, x_64, x_8, x_9, x_10, x_11, x_12, x_13, x_65);
+x_66 = lean_ctor_get(x_64, 1);
+lean_inc(x_66);
+lean_dec(x_64);
+x_67 = l_Lean_Meta_assignExprMVar___at_Lean_Elab_Term_synthesizeInstMVarCore___spec__2(x_5, x_65, x_8, x_9, x_10, x_11, x_12, x_13, x_66);
 lean_dec(x_13);
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
-x_67 = !lean_is_exclusive(x_66);
-if (x_67 == 0)
+x_68 = !lean_is_exclusive(x_67);
+if (x_68 == 0)
 {
-lean_object* x_68; uint8_t x_69; lean_object* x_70; 
-x_68 = lean_ctor_get(x_66, 0);
-lean_dec(x_68);
-x_69 = 1;
-x_70 = lean_box(x_69);
-lean_ctor_set(x_66, 0, x_70);
-return x_66;
+lean_object* x_69; uint8_t x_70; lean_object* x_71; 
+x_69 = lean_ctor_get(x_67, 0);
+lean_dec(x_69);
+x_70 = 1;
+x_71 = lean_box(x_70);
+lean_ctor_set(x_67, 0, x_71);
+return x_67;
 }
 else
 {
-lean_object* x_71; uint8_t x_72; lean_object* x_73; lean_object* x_74; 
-x_71 = lean_ctor_get(x_66, 1);
-lean_inc(x_71);
-lean_dec(x_66);
-x_72 = 1;
-x_73 = lean_box(x_72);
-x_74 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_74, 0, x_73);
-lean_ctor_set(x_74, 1, x_71);
-return x_74;
+lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; 
+x_72 = lean_ctor_get(x_67, 1);
+lean_inc(x_72);
+lean_dec(x_67);
+x_73 = 1;
+x_74 = lean_box(x_73);
+x_75 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_75, 0, x_74);
+lean_ctor_set(x_75, 1, x_72);
+return x_75;
 }
 }
 else
 {
-uint8_t x_75; 
+uint8_t x_76; 
 lean_dec(x_13);
 lean_dec(x_12);
 lean_dec(x_11);
@@ -23896,50 +23443,50 @@ lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_5);
-x_75 = !lean_is_exclusive(x_63);
-if (x_75 == 0)
+x_76 = !lean_is_exclusive(x_64);
+if (x_76 == 0)
 {
-return x_63;
+return x_64;
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; 
-x_76 = lean_ctor_get(x_63, 0);
-x_77 = lean_ctor_get(x_63, 1);
+lean_object* x_77; lean_object* x_78; lean_object* x_79; 
+x_77 = lean_ctor_get(x_64, 0);
+x_78 = lean_ctor_get(x_64, 1);
+lean_inc(x_78);
 lean_inc(x_77);
-lean_inc(x_76);
-lean_dec(x_63);
-x_78 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_78, 0, x_76);
-lean_ctor_set(x_78, 1, x_77);
-return x_78;
+lean_dec(x_64);
+x_79 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_79, 0, x_77);
+lean_ctor_set(x_79, 1, x_78);
+return x_79;
 }
 }
 }
 else
 {
-lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; 
-lean_dec(x_57);
+lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
+lean_dec(x_58);
 lean_dec(x_52);
 lean_free_object(x_40);
-x_79 = l_Lean_Meta_setMCtx___at_Lean_Elab_Term_savingMCtx___spec__1(x_38, x_8, x_9, x_10, x_11, x_12, x_13, x_53);
-x_80 = lean_ctor_get(x_79, 1);
-lean_inc(x_80);
-lean_dec(x_79);
-x_81 = lean_unsigned_to_nat(1u);
-x_82 = lean_nat_add(x_6, x_81);
+x_80 = l_Lean_Meta_setMCtx___at_Lean_Elab_Term_savingMCtx___spec__1(x_38, x_8, x_9, x_10, x_11, x_12, x_13, x_53);
+x_81 = lean_ctor_get(x_80, 1);
+lean_inc(x_81);
+lean_dec(x_80);
+x_82 = lean_unsigned_to_nat(1u);
+x_83 = lean_nat_add(x_6, x_82);
 lean_dec(x_6);
-x_83 = lean_nat_add(x_7, x_81);
+x_84 = lean_nat_add(x_7, x_82);
 lean_dec(x_7);
-x_6 = x_82;
-x_7 = x_83;
-x_14 = x_80;
+x_6 = x_83;
+x_7 = x_84;
+x_14 = x_81;
 goto _start;
 }
 }
 else
 {
-uint8_t x_85; 
+uint8_t x_86; 
 lean_free_object(x_40);
 lean_dec(x_38);
 lean_dec(x_13);
@@ -23953,119 +23500,120 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
-x_85 = !lean_is_exclusive(x_51);
-if (x_85 == 0)
+x_86 = !lean_is_exclusive(x_51);
+if (x_86 == 0)
 {
 return x_51;
 }
 else
 {
-lean_object* x_86; lean_object* x_87; lean_object* x_88; 
-x_86 = lean_ctor_get(x_51, 0);
-x_87 = lean_ctor_get(x_51, 1);
+lean_object* x_87; lean_object* x_88; lean_object* x_89; 
+x_87 = lean_ctor_get(x_51, 0);
+x_88 = lean_ctor_get(x_51, 1);
+lean_inc(x_88);
 lean_inc(x_87);
-lean_inc(x_86);
 lean_dec(x_51);
-x_88 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_88, 0, x_86);
-lean_ctor_set(x_88, 1, x_87);
-return x_88;
+x_89 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_89, 0, x_87);
+lean_ctor_set(x_89, 1, x_88);
+return x_89;
 }
 }
 }
 else
 {
-lean_object* x_89; lean_object* x_90; 
-x_89 = lean_ctor_get(x_40, 0);
-lean_inc(x_89);
+lean_object* x_90; lean_object* x_91; 
+x_90 = lean_ctor_get(x_40, 0);
+lean_inc(x_90);
 lean_dec(x_40);
 lean_inc(x_13);
 lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_2);
-x_90 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_2, x_89, x_10, x_11, x_12, x_13, x_48);
-if (lean_obj_tag(x_90) == 0)
+x_91 = l_Lean_Elab_Term_StructInst_DefaultFields_reduce(x_2, x_90, x_10, x_11, x_12, x_13, x_48);
+if (lean_obj_tag(x_91) == 0)
 {
-lean_object* x_91; lean_object* x_92; size_t x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; 
-x_91 = lean_ctor_get(x_90, 0);
-lean_inc(x_91);
-x_92 = lean_ctor_get(x_90, 1);
+lean_object* x_92; lean_object* x_93; size_t x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; 
+x_92 = lean_ctor_get(x_91, 0);
 lean_inc(x_92);
-lean_dec(x_90);
-x_93 = 8192;
-x_94 = l_Lean_Expr_FindImpl_initCache;
-lean_inc(x_91);
-x_95 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_93, x_91, x_94);
-x_96 = lean_ctor_get(x_95, 0);
-lean_inc(x_96);
-lean_dec(x_95);
-if (lean_obj_tag(x_96) == 0)
+x_93 = lean_ctor_get(x_91, 1);
+lean_inc(x_93);
+lean_dec(x_91);
+x_94 = 8192;
+x_95 = l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__3;
+x_96 = l_Lean_Expr_FindImpl_initCache;
+lean_inc(x_92);
+x_97 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_95, x_94, x_92, x_96);
+x_98 = lean_ctor_get(x_97, 0);
+lean_inc(x_98);
+lean_dec(x_97);
+if (lean_obj_tag(x_98) == 0)
 {
-lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; 
+lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; 
 lean_dec(x_38);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_2);
-x_97 = l_Lean_Elab_Term_getMVarDecl(x_5, x_8, x_9, x_10, x_11, x_12, x_13, x_92);
-x_98 = lean_ctor_get(x_97, 0);
-lean_inc(x_98);
-x_99 = lean_ctor_get(x_97, 1);
-lean_inc(x_99);
-lean_dec(x_97);
-x_100 = lean_ctor_get(x_98, 2);
+x_99 = l_Lean_Elab_Term_getMVarDecl(x_5, x_8, x_9, x_10, x_11, x_12, x_13, x_93);
+x_100 = lean_ctor_get(x_99, 0);
 lean_inc(x_100);
-lean_dec(x_98);
-x_101 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_101, 0, x_100);
-x_102 = lean_box(0);
+x_101 = lean_ctor_get(x_99, 1);
+lean_inc(x_101);
+lean_dec(x_99);
+x_102 = lean_ctor_get(x_100, 2);
+lean_inc(x_102);
+lean_dec(x_100);
+x_103 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_103, 0, x_102);
+x_104 = lean_box(0);
 lean_inc(x_13);
 lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
-x_103 = l_Lean_Elab_Term_ensureHasType(x_101, x_91, x_102, x_8, x_9, x_10, x_11, x_12, x_13, x_99);
-if (lean_obj_tag(x_103) == 0)
+x_105 = l_Lean_Elab_Term_ensureHasType(x_103, x_92, x_104, x_8, x_9, x_10, x_11, x_12, x_13, x_101);
+if (lean_obj_tag(x_105) == 0)
 {
-lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; uint8_t x_109; lean_object* x_110; lean_object* x_111; 
-x_104 = lean_ctor_get(x_103, 0);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_103, 1);
-lean_inc(x_105);
-lean_dec(x_103);
-x_106 = l_Lean_Meta_assignExprMVar___at_Lean_Elab_Term_synthesizeInstMVarCore___spec__2(x_5, x_104, x_8, x_9, x_10, x_11, x_12, x_13, x_105);
+lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; uint8_t x_111; lean_object* x_112; lean_object* x_113; 
+x_106 = lean_ctor_get(x_105, 0);
+lean_inc(x_106);
+x_107 = lean_ctor_get(x_105, 1);
+lean_inc(x_107);
+lean_dec(x_105);
+x_108 = l_Lean_Meta_assignExprMVar___at_Lean_Elab_Term_synthesizeInstMVarCore___spec__2(x_5, x_106, x_8, x_9, x_10, x_11, x_12, x_13, x_107);
 lean_dec(x_13);
 lean_dec(x_12);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
-x_107 = lean_ctor_get(x_106, 1);
-lean_inc(x_107);
-if (lean_is_exclusive(x_106)) {
- lean_ctor_release(x_106, 0);
- lean_ctor_release(x_106, 1);
- x_108 = x_106;
+x_109 = lean_ctor_get(x_108, 1);
+lean_inc(x_109);
+if (lean_is_exclusive(x_108)) {
+ lean_ctor_release(x_108, 0);
+ lean_ctor_release(x_108, 1);
+ x_110 = x_108;
 } else {
- lean_dec_ref(x_106);
- x_108 = lean_box(0);
+ lean_dec_ref(x_108);
+ x_110 = lean_box(0);
 }
-x_109 = 1;
-x_110 = lean_box(x_109);
-if (lean_is_scalar(x_108)) {
- x_111 = lean_alloc_ctor(0, 2, 0);
+x_111 = 1;
+x_112 = lean_box(x_111);
+if (lean_is_scalar(x_110)) {
+ x_113 = lean_alloc_ctor(0, 2, 0);
 } else {
- x_111 = x_108;
+ x_113 = x_110;
 }
-lean_ctor_set(x_111, 0, x_110);
-lean_ctor_set(x_111, 1, x_107);
-return x_111;
+lean_ctor_set(x_113, 0, x_112);
+lean_ctor_set(x_113, 1, x_109);
+return x_113;
 }
 else
 {
-lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; 
 lean_dec(x_13);
 lean_dec(x_12);
 lean_dec(x_11);
@@ -24073,51 +23621,51 @@ lean_dec(x_10);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_5);
-x_112 = lean_ctor_get(x_103, 0);
-lean_inc(x_112);
-x_113 = lean_ctor_get(x_103, 1);
-lean_inc(x_113);
-if (lean_is_exclusive(x_103)) {
- lean_ctor_release(x_103, 0);
- lean_ctor_release(x_103, 1);
- x_114 = x_103;
+x_114 = lean_ctor_get(x_105, 0);
+lean_inc(x_114);
+x_115 = lean_ctor_get(x_105, 1);
+lean_inc(x_115);
+if (lean_is_exclusive(x_105)) {
+ lean_ctor_release(x_105, 0);
+ lean_ctor_release(x_105, 1);
+ x_116 = x_105;
 } else {
- lean_dec_ref(x_103);
- x_114 = lean_box(0);
+ lean_dec_ref(x_105);
+ x_116 = lean_box(0);
 }
-if (lean_is_scalar(x_114)) {
- x_115 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_116)) {
+ x_117 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_115 = x_114;
+ x_117 = x_116;
 }
-lean_ctor_set(x_115, 0, x_112);
-lean_ctor_set(x_115, 1, x_113);
-return x_115;
+lean_ctor_set(x_117, 0, x_114);
+lean_ctor_set(x_117, 1, x_115);
+return x_117;
 }
 }
 else
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; 
-lean_dec(x_96);
-lean_dec(x_91);
-x_116 = l_Lean_Meta_setMCtx___at_Lean_Elab_Term_savingMCtx___spec__1(x_38, x_8, x_9, x_10, x_11, x_12, x_13, x_92);
-x_117 = lean_ctor_get(x_116, 1);
-lean_inc(x_117);
-lean_dec(x_116);
-x_118 = lean_unsigned_to_nat(1u);
-x_119 = lean_nat_add(x_6, x_118);
+lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; 
+lean_dec(x_98);
+lean_dec(x_92);
+x_118 = l_Lean_Meta_setMCtx___at_Lean_Elab_Term_savingMCtx___spec__1(x_38, x_8, x_9, x_10, x_11, x_12, x_13, x_93);
+x_119 = lean_ctor_get(x_118, 1);
+lean_inc(x_119);
+lean_dec(x_118);
+x_120 = lean_unsigned_to_nat(1u);
+x_121 = lean_nat_add(x_6, x_120);
 lean_dec(x_6);
-x_120 = lean_nat_add(x_7, x_118);
+x_122 = lean_nat_add(x_7, x_120);
 lean_dec(x_7);
-x_6 = x_119;
-x_7 = x_120;
-x_14 = x_117;
+x_6 = x_121;
+x_7 = x_122;
+x_14 = x_119;
 goto _start;
 }
 }
 else
 {
-lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; 
+lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; 
 lean_dec(x_38);
 lean_dec(x_13);
 lean_dec(x_12);
@@ -24130,33 +23678,33 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
-x_122 = lean_ctor_get(x_90, 0);
-lean_inc(x_122);
-x_123 = lean_ctor_get(x_90, 1);
-lean_inc(x_123);
-if (lean_is_exclusive(x_90)) {
- lean_ctor_release(x_90, 0);
- lean_ctor_release(x_90, 1);
- x_124 = x_90;
+x_124 = lean_ctor_get(x_91, 0);
+lean_inc(x_124);
+x_125 = lean_ctor_get(x_91, 1);
+lean_inc(x_125);
+if (lean_is_exclusive(x_91)) {
+ lean_ctor_release(x_91, 0);
+ lean_ctor_release(x_91, 1);
+ x_126 = x_91;
 } else {
- lean_dec_ref(x_90);
- x_124 = lean_box(0);
+ lean_dec_ref(x_91);
+ x_126 = lean_box(0);
 }
-if (lean_is_scalar(x_124)) {
- x_125 = lean_alloc_ctor(1, 2, 0);
+if (lean_is_scalar(x_126)) {
+ x_127 = lean_alloc_ctor(1, 2, 0);
 } else {
- x_125 = x_124;
+ x_127 = x_126;
 }
-lean_ctor_set(x_125, 0, x_122);
-lean_ctor_set(x_125, 1, x_123);
-return x_125;
+lean_ctor_set(x_127, 0, x_124);
+lean_ctor_set(x_127, 1, x_125);
+return x_127;
 }
 }
 }
 }
 else
 {
-uint8_t x_126; 
+uint8_t x_128; 
 lean_dec(x_38);
 lean_dec(x_13);
 lean_dec(x_12);
@@ -24169,35 +23717,35 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
-x_126 = !lean_is_exclusive(x_39);
-if (x_126 == 0)
+x_128 = !lean_is_exclusive(x_39);
+if (x_128 == 0)
 {
 return x_39;
 }
 else
 {
-lean_object* x_127; lean_object* x_128; lean_object* x_129; 
-x_127 = lean_ctor_get(x_39, 0);
-x_128 = lean_ctor_get(x_39, 1);
-lean_inc(x_128);
-lean_inc(x_127);
+lean_object* x_129; lean_object* x_130; lean_object* x_131; 
+x_129 = lean_ctor_get(x_39, 0);
+x_130 = lean_ctor_get(x_39, 1);
+lean_inc(x_130);
+lean_inc(x_129);
 lean_dec(x_39);
-x_129 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_129, 0, x_127);
-lean_ctor_set(x_129, 1, x_128);
-return x_129;
+x_131 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_131, 0, x_129);
+lean_ctor_set(x_131, 1, x_130);
+return x_131;
 }
 }
 }
 else
 {
-lean_object* x_130; lean_object* x_131; 
+lean_object* x_132; lean_object* x_133; 
 lean_dec(x_34);
 lean_dec(x_21);
-x_130 = lean_unsigned_to_nat(1u);
-x_131 = lean_nat_add(x_6, x_130);
+x_132 = lean_unsigned_to_nat(1u);
+x_133 = lean_nat_add(x_6, x_132);
 lean_dec(x_6);
-x_6 = x_131;
+x_6 = x_133;
 x_14 = x_28;
 goto _start;
 }
@@ -24206,7 +23754,7 @@ goto _start;
 }
 else
 {
-uint8_t x_133; lean_object* x_134; lean_object* x_135; 
+uint8_t x_135; lean_object* x_136; lean_object* x_137; 
 lean_dec(x_13);
 lean_dec(x_12);
 lean_dec(x_11);
@@ -24218,23 +23766,23 @@ lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
 lean_dec(x_2);
-x_133 = 0;
-x_134 = lean_box(x_133);
-x_135 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_135, 0, x_134);
-lean_ctor_set(x_135, 1, x_14);
-return x_135;
+x_135 = 0;
+x_136 = lean_box(x_135);
+x_137 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_137, 0, x_136);
+lean_ctor_set(x_137, 1, x_14);
+return x_137;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___lambda__1___boxed(lean_object* x_1) {
 _start:
 {
-size_t x_4; lean_object* x_5; 
-x_4 = lean_unbox_usize(x_1);
+uint8_t x_2; lean_object* x_3; 
+x_2 = l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___lambda__1(x_1);
 lean_dec(x_1);
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___spec__1(x_4, x_2, x_3);
-return x_5;
+x_3 = lean_box(x_2);
+return x_3;
 }
 }
 lean_object* l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) {
@@ -24406,7 +23954,7 @@ x_1 = l___private_Lean_Elab_StructInst_0__Lean_Elab_Term_StructInst_getStructSou
 x_2 = l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_step___spec__1___lambda__1___closed__1;
 x_3 = lean_unsigned_to_nat(728u);
 x_4 = lean_unsigned_to_nat(21u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -26891,6 +26439,8 @@ l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__
 lean_mark_persistent(l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__1);
 l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__2 = _init_l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__2();
 lean_mark_persistent(l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__2);
+l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__3 = _init_l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__3();
+lean_mark_persistent(l_Lean_Elab_Term_StructInst_DefaultFields_tryToSynthesizeDefault_loop___closed__3);
 l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_step___spec__1___lambda__1___closed__1 = _init_l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_step___spec__1___lambda__1___closed__1();
 lean_mark_persistent(l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_step___spec__1___lambda__1___closed__1);
 l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_step___spec__1___lambda__1___closed__2 = _init_l_List_forM___main___at_Lean_Elab_Term_StructInst_DefaultFields_step___spec__1___lambda__1___closed__2();
diff --git a/stage0/stdlib/Lean/Elab/Structure.c b/stage0/stdlib/Lean/Elab/Structure.c
index b29ccb3f6e..b07222f78e 100644
--- a/stage0/stdlib/Lean/Elab/Structure.c
+++ b/stage0/stdlib/Lean/Elab/Structure.c
@@ -25,6 +25,7 @@ lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_levelMVarToPar
 lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_withFields_match__1(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_916____spec__1___rarg(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_Array_forMAux___main___at___private_Lean_Elab_Structure_0__Lean_Elab_Command_addDefaults___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_mk_cases_on(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -416,7 +417,6 @@ lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_expandFields_m
 lean_object* l_Lean_Elab_Command_getRef(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_expandDeclSig(lean_object*);
 lean_object* l_Lean_Elab_Command_checkValidFieldModifier___closed__2;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Elab_Command_StructFieldInfo_isSubobject_match__1___rarg(uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_checkValidFieldModifier___lambda__2___closed__3;
 lean_object* l_Lean_Elab_Term_elabType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -6642,7 +6642,7 @@ x_1 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_withFields___rarg___c
 x_2 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_withFields___rarg___closed__11;
 x_3 = lean_unsigned_to_nat(300u);
 x_4 = lean_unsigned_to_nat(37u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Elab/Syntax.c b/stage0/stdlib/Lean/Elab/Syntax.c
index eb94136fb8..419b9b4daf 100644
--- a/stage0/stdlib/Lean/Elab/Syntax.c
+++ b/stage0/stdlib/Lean/Elab/Syntax.c
@@ -28,6 +28,7 @@ lean_object* l_Lean_Elab_Command_expandMixfix___closed__5;
 lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabMacroRules___lambda__1(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_toParserDescrAux___closed__124;
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
 lean_object* lean_erase_macro_scopes(lean_object*);
@@ -124,6 +125,7 @@ lean_object* lean_array_fswap(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_identKind___closed__2;
 lean_object* l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_declareSyntaxCatQuotParser___closed__47;
 lean_object* l_Lean_Elab_Term_toParserDescrAux_match__1(lean_object*);
+extern lean_object* l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
 lean_object* l_Lean_Elab_Command_elabMacroRulesAux___closed__13;
 extern lean_object* l_Lean_Elab_Tactic_mkTacticAttribute___closed__6;
 lean_object* l_Lean_Elab_throwUnsupportedSyntax___at_Lean_Elab_Term_toParserDescrAux___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -300,7 +302,6 @@ lean_object* l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_declareSyntaxCatQ
 lean_object* l___regBuiltin_Lean_Elab_Command_expandElab___closed__2;
 lean_object* l_Lean_Elab_Command_expandElab___closed__49;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__7;
-lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__177;
 lean_object* l_Array_umapMAux___main___at___private_Lean_Elab_Syntax_0__Lean_Elab_Command_expandNotationAux___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__24;
 extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_301____closed__5;
@@ -327,7 +328,6 @@ lean_object* l_Lean_Elab_Command_expandElab___closed__22;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__78;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__153;
 lean_object* l_Lean_Elab_Command_expandMixfix___closed__2;
-extern lean_object* l_Lean_Expr_isSyntheticSorry___closed__1;
 lean_object* l___private_Lean_Elab_Syntax_0__Lean_Elab_Term_markAsTrailingParser___boxed(lean_object*);
 lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__93;
 extern lean_object* l_Lean_Elab_Tactic_mkTacticAttribute___closed__7;
@@ -502,6 +502,7 @@ lean_object* l_List_filterAux___main___at_Lean_Elab_Term_toParserDescrAux___spec
 lean_object* l_Subarray_forInUnsafe_loop___at___private_Lean_Elab_Syntax_0__Lean_Elab_Term_mkParserSeq___spec__1___closed__10;
 lean_object* l_Lean_Elab_Command_expandMixfix___closed__11;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__25;
+extern lean_object* l_Lean_setOptionFromString___closed__5;
 lean_object* l_Array_iterateMAux___main___at_Array_append___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_quotedSymbolKind;
 lean_object* l_Array_umapMAux___main___at_Lean_Elab_Command_expandMacro___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -671,7 +672,6 @@ lean_object* l_Lean_Elab_Command_elabMacroRulesAux___lambda__2(lean_object*, lea
 extern lean_object* l_Lean_Elab_Tactic_evalIntro___closed__5;
 lean_object* l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_declareSyntaxCatQuotParser___closed__42;
 lean_object* l_Lean_Elab_Command_expandElab___closed__11;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Command_elabNoKindMacroRulesAux___closed__7;
 lean_object* l_Lean_Elab_Term_toParserDescrAux___closed__36;
@@ -5772,7 +5772,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Bool_HasRepr___closed__1;
+x_2 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -5781,8 +5781,8 @@ static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__155() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Expr_isSyntheticSorry___closed__1;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__154;
+x_2 = l_Bool_HasRepr___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
@@ -5791,9 +5791,11 @@ static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__156() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__155;
-x_2 = l_Bool_HasRepr___closed__1;
-x_3 = lean_name_mk_string(x_1, x_2);
+x_1 = lean_box(0);
+x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__155;
+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;
 }
 }
@@ -5803,7 +5805,7 @@ _start:
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
 x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__156;
-x_3 = lean_alloc_ctor(0, 2, 0);
+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;
@@ -5812,39 +5814,27 @@ return x_3;
 static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__158() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__157;
-x_3 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_3, 0, x_2);
-lean_ctor_set(x_3, 1, x_1);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__159() {
-_start:
-{
 lean_object* x_1; 
 x_1 = lean_mk_string("ParserDescr.cat");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__160() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__159() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__159;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__158;
 x_2 = lean_string_utf8_byte_size(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__161() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__160() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__159;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__158;
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_Lean_Elab_Term_toParserDescrAux___closed__160;
+x_3 = l_Lean_Elab_Term_toParserDescrAux___closed__159;
 x_4 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_4, 0, x_1);
 lean_ctor_set(x_4, 1, x_2);
@@ -5852,7 +5842,7 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__162() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__161() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -5862,7 +5852,7 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__163() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__162() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
@@ -5872,13 +5862,25 @@ x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__163() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; 
+x_1 = lean_box(0);
+x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__162;
+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_Lean_Elab_Term_toParserDescrAux___closed__164() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
 x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__163;
-x_3 = lean_alloc_ctor(0, 2, 0);
+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;
@@ -5887,33 +5889,21 @@ return x_3;
 static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__165() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__164;
-x_3 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_3, 0, x_2);
-lean_ctor_set(x_3, 1, x_1);
-return x_3;
-}
-}
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__166() {
-_start:
-{
 lean_object* x_1; 
 x_1 = lean_mk_string("unknown category '");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__167() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__166() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__166;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__165;
 x_2 = l_Lean_stringToMessageData(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__168() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__167() {
 _start:
 {
 lean_object* x_1; 
@@ -5921,16 +5911,16 @@ x_1 = lean_mk_string("' or parser declaration");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__169() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__168() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__168;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__167;
 x_2 = l_Lean_stringToMessageData(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__170() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__169() {
 _start:
 {
 lean_object* x_1; 
@@ -5938,12 +5928,22 @@ x_1 = lean_mk_string("unexpected precedence");
 return x_1;
 }
 }
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__170() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; 
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__169;
+x_2 = lean_alloc_ctor(2, 1, 0);
+lean_ctor_set(x_2, 0, x_1);
+return x_2;
+}
+}
 static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__171() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__170;
-x_2 = lean_alloc_ctor(2, 1, 0);
+x_2 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
@@ -5951,31 +5951,21 @@ return x_2;
 static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__172() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__171;
-x_2 = lean_alloc_ctor(0, 1, 0);
-lean_ctor_set(x_2, 0, x_1);
-return x_2;
-}
-}
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__173() {
-_start:
-{
 lean_object* x_1; 
 x_1 = lean_mk_string("ambiguous parser declaration ");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__174() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__173() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__173;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__172;
 x_2 = l_Lean_stringToMessageData(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__175() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__174() {
 _start:
 {
 lean_object* x_1; 
@@ -5983,21 +5973,21 @@ x_1 = lean_mk_string("invalid atomic left recursive syntax");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__176() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__175() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__175;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__174;
 x_2 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__177() {
+static lean_object* _init_l_Lean_Elab_Term_toParserDescrAux___closed__176() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__176;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__175;
 x_2 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_2, 0, x_1);
 return x_2;
@@ -9663,10 +9653,10 @@ x_1158 = lean_array_push(x_1157, x_1156);
 x_1159 = l_Lean_mkStxStrLit(x_1144, x_1153);
 lean_dec(x_1144);
 x_1160 = lean_array_push(x_1157, x_1159);
-x_1161 = l_Lean_Elab_Term_toParserDescrAux___closed__154;
+x_1161 = l_Lean_setOptionFromString___closed__5;
 x_1162 = l_Lean_addMacroScope(x_1150, x_1161, x_1146);
 x_1163 = l_Lean_Elab_Term_toParserDescrAux___closed__153;
-x_1164 = l_Lean_Elab_Term_toParserDescrAux___closed__158;
+x_1164 = l_Lean_Elab_Term_toParserDescrAux___closed__157;
 x_1165 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_1165, 0, x_1153);
 lean_ctor_set(x_1165, 1, x_1163);
@@ -9710,10 +9700,10 @@ x_1181 = lean_array_push(x_1180, x_1179);
 x_1182 = l_Lean_mkStxStrLit(x_1144, x_1176);
 lean_dec(x_1144);
 x_1183 = lean_array_push(x_1180, x_1182);
-x_1184 = l_Lean_Elab_Term_toParserDescrAux___closed__154;
+x_1184 = l_Lean_setOptionFromString___closed__5;
 x_1185 = l_Lean_addMacroScope(x_1172, x_1184, x_1146);
 x_1186 = l_Lean_Elab_Term_toParserDescrAux___closed__153;
-x_1187 = l_Lean_Elab_Term_toParserDescrAux___closed__158;
+x_1187 = l_Lean_Elab_Term_toParserDescrAux___closed__157;
 x_1188 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_1188, 0, x_1176);
 lean_ctor_set(x_1188, 1, x_1186);
@@ -9809,11 +9799,11 @@ x_1264 = l_Lean_Syntax_getArg(x_1, x_1263);
 lean_dec(x_1);
 x_1265 = lean_alloc_ctor(4, 1, 0);
 lean_ctor_set(x_1265, 0, x_1199);
-x_1266 = l_Lean_Elab_Term_toParserDescrAux___closed__167;
+x_1266 = l_Lean_Elab_Term_toParserDescrAux___closed__166;
 x_1267 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_1267, 0, x_1266);
 lean_ctor_set(x_1267, 1, x_1265);
-x_1268 = l_Lean_Elab_Term_toParserDescrAux___closed__169;
+x_1268 = l_Lean_Elab_Term_toParserDescrAux___closed__168;
 x_1269 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_1269, 0, x_1267);
 lean_ctor_set(x_1269, 1, x_1268);
@@ -9865,7 +9855,7 @@ lean_dec(x_1203);
 x_1277 = lean_unsigned_to_nat(3u);
 x_1278 = l_Lean_Syntax_getArg(x_1, x_1277);
 lean_dec(x_1);
-x_1279 = l_Lean_Elab_Term_toParserDescrAux___closed__172;
+x_1279 = l_Lean_Elab_Term_toParserDescrAux___closed__171;
 x_1280 = l_Lean_throwErrorAt___at_Lean_Elab_Term_checkLeftRec___spec__1___rarg(x_1278, x_1279, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_1260);
 lean_dec(x_9);
 lean_dec(x_7);
@@ -9906,7 +9896,7 @@ lean_dec(x_1);
 x_1287 = l_List_map___main___at_Lean_Elab_Term_toParserDescrAux___spec__7(x_1262);
 x_1288 = l_Lean_MessageData_ofList(x_1287);
 lean_dec(x_1287);
-x_1289 = l_Lean_Elab_Term_toParserDescrAux___closed__174;
+x_1289 = l_Lean_Elab_Term_toParserDescrAux___closed__173;
 x_1290 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_1290, 0, x_1289);
 lean_ctor_set(x_1290, 1, x_1288);
@@ -10004,11 +9994,11 @@ if (x_1213 == 0)
 {
 lean_object* x_1214; lean_object* x_1215; lean_object* x_1216; lean_object* x_1217; lean_object* x_1218; lean_object* x_1219; lean_object* x_1220; lean_object* x_1221; lean_object* x_1222; lean_object* x_1223; lean_object* x_1224; lean_object* x_1225; lean_object* x_1226; lean_object* x_1227; lean_object* x_1228; lean_object* x_1229; lean_object* x_1230; lean_object* x_1231; lean_object* x_1232; lean_object* x_1233; 
 x_1214 = lean_ctor_get(x_1212, 0);
-x_1215 = l_Lean_Elab_Term_toParserDescrAux___closed__162;
+x_1215 = l_Lean_Elab_Term_toParserDescrAux___closed__161;
 x_1216 = l_Lean_addMacroScope(x_1214, x_1215, x_1210);
 x_1217 = l_Lean_SourceInfo_inhabited___closed__1;
-x_1218 = l_Lean_Elab_Term_toParserDescrAux___closed__161;
-x_1219 = l_Lean_Elab_Term_toParserDescrAux___closed__165;
+x_1218 = l_Lean_Elab_Term_toParserDescrAux___closed__160;
+x_1219 = l_Lean_Elab_Term_toParserDescrAux___closed__164;
 x_1220 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_1220, 0, x_1217);
 lean_ctor_set(x_1220, 1, x_1218);
@@ -10042,11 +10032,11 @@ x_1235 = lean_ctor_get(x_1212, 1);
 lean_inc(x_1235);
 lean_inc(x_1234);
 lean_dec(x_1212);
-x_1236 = l_Lean_Elab_Term_toParserDescrAux___closed__162;
+x_1236 = l_Lean_Elab_Term_toParserDescrAux___closed__161;
 x_1237 = l_Lean_addMacroScope(x_1234, x_1236, x_1210);
 x_1238 = l_Lean_SourceInfo_inhabited___closed__1;
-x_1239 = l_Lean_Elab_Term_toParserDescrAux___closed__161;
-x_1240 = l_Lean_Elab_Term_toParserDescrAux___closed__165;
+x_1239 = l_Lean_Elab_Term_toParserDescrAux___closed__160;
+x_1240 = l_Lean_Elab_Term_toParserDescrAux___closed__164;
 x_1241 = lean_alloc_ctor(3, 4, 0);
 lean_ctor_set(x_1241, 0, x_1238);
 lean_ctor_set(x_1241, 1, x_1239);
@@ -10080,7 +10070,7 @@ else
 {
 lean_object* x_1299; lean_object* x_1300; 
 lean_dec(x_1199);
-x_1299 = l_Lean_Elab_Term_toParserDescrAux___closed__177;
+x_1299 = l_Lean_Elab_Term_toParserDescrAux___closed__176;
 x_1300 = l_Lean_throwErrorAt___at_Lean_Elab_Term_checkLeftRec___spec__1___rarg(x_1, x_1299, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
 lean_dec(x_9);
 lean_dec(x_7);
@@ -10227,7 +10217,7 @@ else
 {
 lean_object* x_1336; lean_object* x_1337; uint8_t x_1338; 
 lean_dec(x_1312);
-x_1336 = l_Lean_Elab_Term_toParserDescrAux___closed__177;
+x_1336 = l_Lean_Elab_Term_toParserDescrAux___closed__176;
 x_1337 = l_Lean_throwErrorAt___at_Lean_Elab_Term_checkLeftRec___spec__1___rarg(x_1, x_1336, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_1330);
 lean_dec(x_9);
 lean_dec(x_7);
@@ -10573,7 +10563,7 @@ x_1 = l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_getCatSuffix___closed__1
 x_2 = l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_getCatSuffix___closed__2;
 x_3 = lean_unsigned_to_nat(187u);
 x_4 = lean_unsigned_to_nat(20u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -11114,7 +11104,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__163;
+x_2 = l_Lean_Elab_Term_toParserDescrAux___closed__162;
 x_3 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_3, 0, x_2);
 lean_ctor_set(x_3, 1, x_1);
@@ -11366,7 +11356,7 @@ 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_array_push(x_24, x_104);
-x_106 = l_Lean_Elab_Term_toParserDescrAux___closed__163;
+x_106 = l_Lean_Elab_Term_toParserDescrAux___closed__162;
 x_107 = l_Lean_addMacroScope(x_16, x_106, x_13);
 x_108 = l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_declareSyntaxCatQuotParser___closed__49;
 x_109 = l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_declareSyntaxCatQuotParser___closed__51;
@@ -13146,7 +13136,7 @@ static lean_object* _init_l_Lean_Elab_Command_elabSyntax___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__166;
+x_1 = l_Lean_Elab_Term_toParserDescrAux___closed__165;
 x_2 = lean_alloc_ctor(2, 1, 0);
 lean_ctor_set(x_2, 0, x_1);
 return x_2;
@@ -23683,8 +23673,6 @@ l_Lean_Elab_Term_toParserDescrAux___closed__175 = _init_l_Lean_Elab_Term_toParse
 lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___closed__175);
 l_Lean_Elab_Term_toParserDescrAux___closed__176 = _init_l_Lean_Elab_Term_toParserDescrAux___closed__176();
 lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___closed__176);
-l_Lean_Elab_Term_toParserDescrAux___closed__177 = _init_l_Lean_Elab_Term_toParserDescrAux___closed__177();
-lean_mark_persistent(l_Lean_Elab_Term_toParserDescrAux___closed__177);
 l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_getCatSuffix___closed__1 = _init_l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_getCatSuffix___closed__1();
 lean_mark_persistent(l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_getCatSuffix___closed__1);
 l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_getCatSuffix___closed__2 = _init_l___private_Lean_Elab_Syntax_0__Lean_Elab_Command_getCatSuffix___closed__2();
diff --git a/stage0/stdlib/Lean/Elab/SyntheticMVars.c b/stage0/stdlib/Lean/Elab/SyntheticMVars.c
index c473a168da..e8d1593424 100644
--- a/stage0/stdlib/Lean/Elab/SyntheticMVars.c
+++ b/stage0/stdlib/Lean/Elab/SyntheticMVars.c
@@ -20,6 +20,7 @@ lean_object* l_Lean_Elab_Term_liftTacticElabM___rarg___closed__2;
 lean_object* l_Lean_Elab_Term_ensureAssignmentHasNoMVars___closed__2;
 lean_object* l_Lean_Meta_withMVarContext___at___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizeSyntheticMVarsStep___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forInAux___main___at___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_reportStuckSyntheticMVars___spec__1___closed__1;
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l_Lean_Meta_withMVarContext___at_Lean_Elab_Term_liftTacticElabM___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_checkWithDefault(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -162,7 +163,6 @@ lean_object* l___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizePe
 lean_object* l_List_filterAuxM___main___at___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizeSyntheticMVarsStep___spec__2(uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getPos(lean_object*);
 lean_object* l_Lean_Elab_Term_runTactic___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Elab_Term_runTactic___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_synthesizeSyntheticMVarsNoPostponing(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*);
@@ -1846,7 +1846,7 @@ x_1 = l___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizePendingIn
 x_2 = l___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizePendingInstMVar___lambda__1___closed__2;
 x_3 = lean_unsigned_to_nat(85u);
 x_4 = lean_unsigned_to_nat(34u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -2016,7 +2016,7 @@ x_1 = l___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizePendingIn
 x_2 = l___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizePendingCoeInstMVar___lambda__1___closed__1;
 x_3 = lean_unsigned_to_nat(96u);
 x_4 = lean_unsigned_to_nat(31u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -4712,7 +4712,7 @@ x_1 = l___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_synthesizePendingIn
 x_2 = l_List_forInAux___main___at___private_Lean_Elab_SyntheticMVars_0__Lean_Elab_Term_reportStuckSyntheticMVars___spec__1___closed__2;
 x_3 = lean_unsigned_to_nat(180u);
 x_4 = lean_unsigned_to_nat(9u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Elab/Tactic/Basic.c b/stage0/stdlib/Lean/Elab/Tactic/Basic.c
index 70113f560c..d712c0d07c 100644
--- a/stage0/stdlib/Lean/Elab/Tactic/Basic.c
+++ b/stage0/stdlib/Lean/Elab/Tactic/Basic.c
@@ -138,6 +138,7 @@ lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Elab_Tactic_setGoals___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Basic_0__Lean_Elab_Tactic_evalTacticUsing_loop_match__2(lean_object*);
 lean_object* l_Lean_Elab_Tactic_liftMetaMAtMain_match__1___rarg(lean_object*, lean_object*);
+uint8_t l_Lean_Name_isPrefixOf(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_getGoals___boxed(lean_object*);
 extern lean_object* l_Lean_Name_inhabited;
 lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Tactic_evalClear___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -271,7 +272,6 @@ lean_object* l___private_Lean_Elab_Tactic_Basic_0__Lean_Elab_Tactic_regTraceClas
 lean_object* l___regBuiltin_Lean_Elab_Tactic_evalFocus___closed__2;
 lean_object* l_Lean_Elab_Tactic_getUnsolvedGoals(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_evalIntros___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Name_isPrefixOf___main(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Tactic_expandTacticMacroFns_loop___spec__2___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_Elab_Tactic_getGoals___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Elab_Tactic_expandTacticMacroFns_loop___spec__2(lean_object*);
@@ -439,6 +439,7 @@ lean_object* l_Lean_Syntax_getKind(lean_object*);
 lean_object* l_Lean_Elab_Tactic_withMainMVarContext_match__1(lean_object*);
 lean_object* l_Lean_Elab_Tactic_getFVarId(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_ensureHasNoMVars___closed__1;
+uint8_t l_Lean_Name_isSuffixOf(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_evalIntro___closed__1;
 lean_object* l_Lean_Elab_Tactic_evalAssumption(lean_object*);
 lean_object* l_Lean_Elab_Tactic_evalIntro___closed__8;
@@ -462,7 +463,6 @@ lean_object* l_Std_PersistentHashMap_findAtAux___main___at_Lean_Elab_Tactic_eval
 lean_object* l_Lean_Elab_Tactic_tagUntaggedGoals_match__2(lean_object*);
 extern lean_object* l_Array_myMacro____x40_Init_Data_Array_Macros___hyg_464____closed__16;
 lean_object* l_Lean_Elab_Tactic_evalIntro___closed__9;
-uint8_t l_Lean_Name_isSuffixOf___main(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_evalFailIfSuccess(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_evalIntros_match__1(lean_object*);
 lean_object* l_Lean_Elab_Tactic_evalOrelse___closed__1;
@@ -14676,7 +14676,7 @@ x_19 = lean_ctor_get(x_16, 1);
 x_20 = lean_ctor_get(x_18, 0);
 lean_inc(x_20);
 lean_dec(x_18);
-x_21 = l_Lean_Name_isSuffixOf___main(x_1, x_20);
+x_21 = l_Lean_Name_isSuffixOf(x_1, x_20);
 lean_dec(x_20);
 if (x_21 == 0)
 {
@@ -14707,7 +14707,7 @@ lean_dec(x_16);
 x_26 = lean_ctor_get(x_24, 0);
 lean_inc(x_26);
 lean_dec(x_24);
-x_27 = l_Lean_Name_isSuffixOf___main(x_1, x_26);
+x_27 = l_Lean_Name_isSuffixOf(x_1, x_26);
 lean_dec(x_26);
 if (x_27 == 0)
 {
@@ -14790,7 +14790,7 @@ x_19 = lean_ctor_get(x_16, 1);
 x_20 = lean_ctor_get(x_18, 0);
 lean_inc(x_20);
 lean_dec(x_18);
-x_21 = l_Lean_Name_isPrefixOf___main(x_1, x_20);
+x_21 = l_Lean_Name_isPrefixOf(x_1, x_20);
 lean_dec(x_20);
 if (x_21 == 0)
 {
@@ -14821,7 +14821,7 @@ lean_dec(x_16);
 x_26 = lean_ctor_get(x_24, 0);
 lean_inc(x_26);
 lean_dec(x_24);
-x_27 = l_Lean_Name_isPrefixOf___main(x_1, x_26);
+x_27 = l_Lean_Name_isPrefixOf(x_1, x_26);
 lean_dec(x_26);
 if (x_27 == 0)
 {
diff --git a/stage0/stdlib/Lean/Elab/Tactic/Induction.c b/stage0/stdlib/Lean/Elab/Tactic/Induction.c
index 687e650a1f..40f4f99d83 100644
--- a/stage0/stdlib/Lean/Elab/Tactic/Induction.c
+++ b/stage0/stdlib/Lean/Elab/Tactic/Induction.c
@@ -13,7 +13,6 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_generalizeMajor___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_Elab_Tactic_evalCases(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findIdxAux___main___at___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getRecInfo___spec__2(lean_object*, lean_object*, lean_object*);
@@ -82,6 +81,7 @@ lean_object* l_Lean_Elab_Tactic_getInductiveValFromMajor___lambda__1___closed__2
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getRecInfoDefault_match__4___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_getRecFromUsing_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getAppFn___main(lean_object*);
@@ -252,6 +252,7 @@ lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getRecIn
 lean_object* l_Lean_Syntax_getArgs(lean_object*);
 lean_object* l_ReaderT_bind___at_Lean_Elab_Tactic_liftMetaTacticAux___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*);
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getRecInfoDefault_match__3(lean_object*);
+uint8_t l_Lean_Name_isSuffixOf(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_saveBacktrackableState___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_evalInduction(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
@@ -266,7 +267,6 @@ lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getRecFr
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_elabMajor___lambda__1___closed__2;
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getRecInfo_match__4(lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_generalizeVars___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Name_isSuffixOf___main(lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Tactic_evalCases_match__1(lean_object*);
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getRecInfoDefault___closed__1;
 lean_object* l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getAltName___boxed(lean_object*);
@@ -1625,7 +1625,7 @@ lean_object* x_4; lean_object* x_5; uint8_t x_6; uint8_t x_7;
 x_4 = lean_ctor_get(x_3, 0);
 x_5 = lean_ctor_get(x_3, 1);
 x_6 = l_List_foldr___main___at___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_checkAltCtorNames___spec__1(x_1, x_2, x_5);
-x_7 = l_Lean_Name_isSuffixOf___main(x_1, x_4);
+x_7 = l_Lean_Name_isSuffixOf(x_1, x_4);
 if (x_7 == 0)
 {
 return x_6;
@@ -4244,7 +4244,7 @@ lean_object* x_7; lean_object* x_8; uint8_t x_9;
 x_7 = lean_array_fget(x_2, x_3);
 x_8 = l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_getAltName(x_7);
 lean_dec(x_7);
-x_9 = l_Lean_Name_isSuffixOf___main(x_8, x_1);
+x_9 = l_Lean_Name_isSuffixOf(x_8, x_1);
 lean_dec(x_8);
 if (x_9 == 0)
 {
@@ -8873,7 +8873,7 @@ x_15 = lean_nat_dec_eq(x_13, x_14);
 if (x_15 == 0)
 {
 lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
-x_16 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_14);
+x_16 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_14);
 x_17 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_17, 0, x_16);
 x_18 = l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_processResult___closed__2;
@@ -8884,7 +8884,7 @@ x_20 = l___private_Lean_Elab_Tactic_Induction_0__Lean_Elab_Tactic_processResult_
 x_21 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_21, 0, x_19);
 lean_ctor_set(x_21, 1, x_20);
-x_22 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_13);
+x_22 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_13);
 x_23 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_23, 0, x_22);
 x_24 = lean_alloc_ctor(10, 2, 0);
diff --git a/stage0/stdlib/Lean/Elab/Term.c b/stage0/stdlib/Lean/Elab/Term.c
index 83f70d24fe..c93eda6612 100644
--- a/stage0/stdlib/Lean/Elab/Term.c
+++ b/stage0/stdlib/Lean/Elab/Term.c
@@ -37,6 +37,7 @@ lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hy
 lean_object* l_Lean_Elab_Term_MVarErrorInfo_logError___closed__6;
 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_Meta_inferType___at___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isType___at_Lean_Elab_Term_ensureType___spec__1(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___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*);
@@ -841,7 +842,6 @@ lean_object* l_Lean_Syntax_getPos(lean_object*);
 lean_object* l_Lean_Elab_Term_getMessageLog___boxed(lean_object*);
 lean_object* l_Lean_Elab_Term_Lean_Elab_Term___instance__6___rarg___closed__1;
 lean_object* l_Lean_Elab_Term_isLocalIdent_x3f_match__1(lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Array_forMAux___main___at_Lean_Elab_Term_Lean_Elab_Term___instance__6___spec__6(lean_object*, lean_object*, lean_object*, 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* l_Lean_throwErrorAt___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -883,7 +883,6 @@ extern lean_object* l_Lean_Meta_mkSorry___rarg___lambda__1___closed__2;
 lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabImplicitLambda_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_mkFreshExprMVarImpl(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkFreshLevelMVar___at_Lean_Elab_Term_ensureType___spec__2(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_FileMap_Inhabited___closed__1;
 lean_object* l_Lean_Elab_Term_getLetRecsToLift___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkOptionalNode___closed__1;
 lean_object* l_Lean_Elab_Term_Lean_Elab_Term___instance__5___closed__4;
@@ -978,6 +977,7 @@ lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_tryCoe___closed__5;
 lean_object* l_Lean_Meta_mkFreshLevelMVar___at_Lean_Elab_Term_ensureType___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getArg(lean_object*, lean_object*);
 lean_object* l___regBuiltin_Lean_Elab_Term_elabEnsureExpectedType___closed__3;
+extern lean_object* l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1;
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
 lean_object* l_Lean_Elab_Term_monadLog___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Elab_Term_logUnassignedUsingErrorInfos_match__1(lean_object*);
@@ -2491,7 +2491,7 @@ x_1 = l_Lean_Elab_Term_getFVarLocalDecl_x21___closed__2;
 x_2 = l_Lean_Elab_Term_getFVarLocalDecl_x21___closed__3;
 x_3 = lean_unsigned_to_nat(222u);
 x_4 = lean_unsigned_to_nat(14u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -34877,7 +34877,7 @@ lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_obj
 x_1 = lean_box(0);
 x_2 = lean_box(0);
 x_3 = l___private_Lean_Elab_Term_0__Lean_Elab_Term_mkSomeContext___closed__1;
-x_4 = l_Lean_FileMap_Inhabited___closed__1;
+x_4 = l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1;
 x_5 = lean_box(0);
 x_6 = l_Lean_firstFrontendMacroScope;
 x_7 = 1;
diff --git a/stage0/stdlib/Lean/Environment.c b/stage0/stdlib/Lean/Environment.c
index bf33c046cb..1360ac61b3 100644
--- a/stage0/stdlib/Lean/Environment.c
+++ b/stage0/stdlib/Lean/Environment.c
@@ -51,7 +51,6 @@ lean_object* l_Lean_EnvExtension_setState(lean_object*);
 lean_object* l_Std_AssocList_find_x3f___at_Lean_Environment_find_x3f___spec__3___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_displayStats___closed__1;
 lean_object* l_Nat_foldAux___main___at_Lean_mkModuleData___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l_Array_iterateMAux___main___at_Lean_importModules___spec__10(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at_Lean_Environment_freeRegions___spec__1___boxed(lean_object*, lean_object*, lean_object*);
@@ -102,13 +101,13 @@ size_t l_USize_sub(size_t, size_t);
 extern lean_object* l_Array_empty___closed__1;
 lean_object* lean_environment_find(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_Inhabited___closed__4;
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_importModules___spec__14(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* lean_read_module_data(lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__3___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_TagDeclarationExtension_Inhabited___closed__1;
 lean_object* l_Array_iterateMAux___main___at_Lean_importModules___spec__13(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_NameSet_Lean_Data_Name___instance__7;
 uint8_t l_Lean_ConstantInfo_isUnsafe(lean_object*);
 lean_object* l_Lean_mkTagDeclarationExtension___closed__2;
 lean_object* l_Lean_PersistentEnvExtension_setState___rarg(lean_object*, lean_object*, lean_object*);
@@ -204,6 +203,7 @@ lean_object* l_Lean_EnvExtensionInterfaceImp___elambda__3___rarg(lean_object*, l
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Lean_SimplePersistentEnvExtension_modifyState___rarg___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
+lean_object* l_Lean_Environment_hasUnsafe___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Environment_11__finalizePersistentExtensions(lean_object*, lean_object*, lean_object*);
 lean_object* lean_environment_add_modification(lean_object*, lean_object*);
 lean_object* l_Lean_serializeModifications___boxed(lean_object*, lean_object*);
@@ -375,9 +375,7 @@ lean_object* l_fix1___rarg___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_imp;
 lean_object* l_Array_forMAux___main___at_Lean_Environment_displayStats___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_PersistentHashMap_containsAux___main___at_Lean_Environment_contains___spec__4(lean_object*, size_t, lean_object*);
-size_t l_USize_mod(size_t, size_t);
 lean_object* l_Lean_namespacesExt___elambda__2___boxed(lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__3;
 lean_object* l_Lean_PersistentEnvExtension_setState___rarg___lambda__1(lean_object*, lean_object*);
 uint32_t lean_environment_trust_level(lean_object*);
@@ -396,7 +394,6 @@ lean_object* l___private_Lean_Environment_12__isNamespaceName___boxed(lean_objec
 lean_object* lean_import_modules(lean_object*, lean_object*, uint32_t, lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Environment_getModuleIdxFor_x3f___spec__1(lean_object*, lean_object*);
 extern lean_object* l_monadControlRefl___rarg___lambda__2___closed__1;
-size_t lean_ptr_addr(lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_registerExt___rarg___closed__1;
 lean_object* l_Std_HashMap_numBuckets___at_Lean_Environment_displayStats___spec__6(lean_object*);
@@ -419,6 +416,7 @@ lean_object* l_Lean_PersistentEnvExtension_modifyState___rarg___boxed(lean_objec
 lean_object* l_Lean_withImportModules___rarg(lean_object*, lean_object*, uint32_t, lean_object*, lean_object*);
 lean_object* l_Lean_mkStateFromImportedEntries(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_addAndCompile(lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_Environment_hasUnsafe___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_namespacesExt___closed__5;
 lean_object* l_Lean_regModListExtension(lean_object*);
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___boxed(lean_object*, lean_object*, lean_object*);
@@ -431,7 +429,6 @@ lean_object* l_Lean_namespacesExt___closed__3;
 lean_object* l_Lean_Kernel_whnf___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_inhabited___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__4___closed__1;
-extern lean_object* l_Lean_NameSet_Inhabited;
 lean_object* l___private_Lean_Environment_14__throwUnexpectedType___rarg___closed__3;
 lean_object* l_Array_iterateMAux___main___at_Lean_mkModuleData___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_EnvExtensionInterfaceImp___elambda__4(lean_object*, lean_object*);
@@ -496,6 +493,7 @@ lean_object* l_Std_mkHashMap___at_Lean_Environment_Inhabited___spec__1(lean_obje
 lean_object* l_Lean_modListExtension;
 lean_object* l_Lean_EnvExtensionInterfaceImp___elambda__1(lean_object*);
 lean_object* l_Lean_TagDeclarationExtension_isTagged___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Environment_isConstructor___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Environment_14__throwUnexpectedType___rarg___closed__1;
 uint8_t l_Lean_NameSet_contains(lean_object*, lean_object*);
@@ -1530,54 +1528,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_Environment_addAux___spec__2(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_Environment_addAux___spec__2(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_Environment_addAux___spec__2(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_Environment_addAux___spec__6(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_Environment_addAux___spec__6(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_Environment_addAux___spec__6(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_Environment_addAux___spec__6(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
@@ -6332,7 +6336,7 @@ static lean_object* _init_l_Lean_TagDeclarationExtension_Inhabited___closed__1()
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_NameSet_Inhabited;
+x_1 = l_Lean_NameSet_Lean_Data_Name___instance__7;
 x_2 = l_Lean_SimplePersistentEnvExtension_Inhabited___rarg(x_1);
 return x_2;
 }
@@ -10890,584 +10894,77 @@ lean_dec(x_2);
 return x_5;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
+uint8_t l_Lean_Environment_hasUnsafe___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; size_t x_110; size_t x_111; lean_object* x_112; size_t x_113; uint8_t x_114; 
-x_110 = lean_ptr_addr(x_3);
-x_111 = x_2 == 0 ? 0 : x_110 % x_2;
-x_112 = lean_array_uget(x_4, x_111);
-x_113 = lean_ptr_addr(x_112);
-lean_dec(x_112);
-x_114 = x_113 == x_110;
-if (x_114 == 0)
+if (lean_obj_tag(x_2) == 4)
 {
-lean_object* x_115; uint8_t x_116; 
+lean_object* x_3; lean_object* x_4; 
+x_3 = lean_ctor_get(x_2, 0);
 lean_inc(x_3);
-x_115 = lean_array_uset(x_4, x_111, x_3);
-x_116 = 0;
-x_5 = x_116;
-x_6 = x_115;
-goto block_109;
+lean_dec(x_2);
+x_4 = lean_environment_find(x_1, x_3);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_5; 
+x_5 = 0;
+return x_5;
 }
 else
 {
-uint8_t x_117; 
-x_117 = 1;
-x_5 = x_117;
-x_6 = x_4;
-goto block_109;
+lean_object* x_6; uint8_t x_7; 
+x_6 = lean_ctor_get(x_4, 0);
+lean_inc(x_6);
+lean_dec(x_4);
+x_7 = l_Lean_ConstantInfo_isUnsafe(x_6);
+lean_dec(x_6);
+return x_7;
 }
-block_109:
-{
-lean_object* x_7; 
-if (x_5 == 0)
-{
-if (lean_obj_tag(x_3) == 4)
-{
-lean_object* x_93; lean_object* x_94; 
-x_93 = lean_ctor_get(x_3, 0);
-lean_inc(x_93);
-lean_inc(x_1);
-x_94 = lean_environment_find(x_1, x_93);
-if (lean_obj_tag(x_94) == 0)
-{
-lean_object* x_95; 
-x_95 = lean_box(0);
-x_7 = x_95;
-goto block_92;
 }
 else
 {
-uint8_t x_96; 
-x_96 = !lean_is_exclusive(x_94);
-if (x_96 == 0)
-{
-lean_object* x_97; uint8_t x_98; 
-x_97 = lean_ctor_get(x_94, 0);
-x_98 = l_Lean_ConstantInfo_isUnsafe(x_97);
-lean_dec(x_97);
-if (x_98 == 0)
-{
-lean_object* x_99; 
-lean_free_object(x_94);
-x_99 = lean_box(0);
-x_7 = x_99;
-goto block_92;
-}
-else
-{
-lean_object* x_100; 
+uint8_t x_8; 
+lean_dec(x_2);
 lean_dec(x_1);
-lean_ctor_set(x_94, 0, x_3);
-x_100 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_100, 0, x_94);
-lean_ctor_set(x_100, 1, x_6);
-return x_100;
-}
-}
-else
-{
-lean_object* x_101; uint8_t x_102; 
-x_101 = lean_ctor_get(x_94, 0);
-lean_inc(x_101);
-lean_dec(x_94);
-x_102 = l_Lean_ConstantInfo_isUnsafe(x_101);
-lean_dec(x_101);
-if (x_102 == 0)
-{
-lean_object* x_103; 
-x_103 = lean_box(0);
-x_7 = x_103;
-goto block_92;
-}
-else
-{
-lean_object* x_104; lean_object* x_105; 
-lean_dec(x_1);
-x_104 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_104, 0, x_3);
-x_105 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_105, 0, x_104);
-lean_ctor_set(x_105, 1, x_6);
-return x_105;
-}
-}
-}
-}
-else
-{
-lean_object* x_106; 
-x_106 = lean_box(0);
-x_7 = x_106;
-goto block_92;
-}
-}
-else
-{
-lean_object* x_107; lean_object* x_108; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_107 = lean_box(0);
-x_108 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_108, 0, x_107);
-lean_ctor_set(x_108, 1, x_6);
-return x_108;
-}
-block_92:
-{
-lean_dec(x_7);
-switch (lean_obj_tag(x_3)) {
-case 5:
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-lean_dec(x_3);
-lean_inc(x_1);
-x_10 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_8, x_6);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-lean_dec(x_10);
-x_3 = x_9;
-x_4 = x_12;
-goto _start;
-}
-else
-{
-uint8_t x_14; 
-lean_dec(x_9);
-lean_dec(x_1);
-x_14 = !lean_is_exclusive(x_10);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_10, 0);
-lean_dec(x_15);
-x_16 = !lean_is_exclusive(x_11);
-if (x_16 == 0)
-{
-return x_10;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-x_17 = lean_ctor_get(x_11, 0);
-lean_inc(x_17);
-lean_dec(x_11);
-x_18 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_10, 0, x_18);
-return x_10;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_10, 1);
-lean_inc(x_19);
-lean_dec(x_10);
-x_20 = lean_ctor_get(x_11, 0);
-lean_inc(x_20);
-if (lean_is_exclusive(x_11)) {
- lean_ctor_release(x_11, 0);
- x_21 = x_11;
-} else {
- lean_dec_ref(x_11);
- x_21 = lean_box(0);
-}
-if (lean_is_scalar(x_21)) {
- x_22 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_22 = x_21;
-}
-lean_ctor_set(x_22, 0, x_20);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_22);
-lean_ctor_set(x_23, 1, x_19);
-return x_23;
-}
-}
-}
-case 6:
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = lean_ctor_get(x_3, 1);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_3, 2);
-lean_inc(x_25);
-lean_dec(x_3);
-lean_inc(x_1);
-x_26 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_24, x_6);
-x_27 = lean_ctor_get(x_26, 0);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; 
-x_28 = lean_ctor_get(x_26, 1);
-lean_inc(x_28);
-lean_dec(x_26);
-x_3 = x_25;
-x_4 = x_28;
-goto _start;
-}
-else
-{
-uint8_t x_30; 
-lean_dec(x_25);
-lean_dec(x_1);
-x_30 = !lean_is_exclusive(x_26);
-if (x_30 == 0)
-{
-lean_object* x_31; uint8_t x_32; 
-x_31 = lean_ctor_get(x_26, 0);
-lean_dec(x_31);
-x_32 = !lean_is_exclusive(x_27);
-if (x_32 == 0)
-{
-return x_26;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_27, 0);
-lean_inc(x_33);
-lean_dec(x_27);
-x_34 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_34, 0, x_33);
-lean_ctor_set(x_26, 0, x_34);
-return x_26;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_35 = lean_ctor_get(x_26, 1);
-lean_inc(x_35);
-lean_dec(x_26);
-x_36 = lean_ctor_get(x_27, 0);
-lean_inc(x_36);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- x_37 = x_27;
-} else {
- lean_dec_ref(x_27);
- x_37 = lean_box(0);
-}
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_38 = x_37;
-}
-lean_ctor_set(x_38, 0, x_36);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_35);
-return x_39;
-}
-}
-}
-case 7:
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_40 = lean_ctor_get(x_3, 1);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_3, 2);
-lean_inc(x_41);
-lean_dec(x_3);
-lean_inc(x_1);
-x_42 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_40, x_6);
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; 
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_3 = x_41;
-x_4 = x_44;
-goto _start;
-}
-else
-{
-uint8_t x_46; 
-lean_dec(x_41);
-lean_dec(x_1);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_42, 0);
-lean_dec(x_47);
-x_48 = !lean_is_exclusive(x_43);
-if (x_48 == 0)
-{
-return x_42;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; 
-x_49 = lean_ctor_get(x_43, 0);
-lean_inc(x_49);
-lean_dec(x_43);
-x_50 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_42, 0, x_50);
-return x_42;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_51 = lean_ctor_get(x_42, 1);
-lean_inc(x_51);
-lean_dec(x_42);
-x_52 = lean_ctor_get(x_43, 0);
-lean_inc(x_52);
-if (lean_is_exclusive(x_43)) {
- lean_ctor_release(x_43, 0);
- x_53 = x_43;
-} else {
- lean_dec_ref(x_43);
- x_53 = lean_box(0);
-}
-if (lean_is_scalar(x_53)) {
- x_54 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_54 = x_53;
-}
-lean_ctor_set(x_54, 0, x_52);
-x_55 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_51);
-return x_55;
-}
-}
-}
-case 8:
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_56 = lean_ctor_get(x_3, 1);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_3, 2);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_3, 3);
-lean_inc(x_58);
-lean_dec(x_3);
-lean_inc(x_1);
-x_59 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_56, x_6);
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_59, 1);
-lean_inc(x_61);
-lean_dec(x_59);
-lean_inc(x_1);
-x_62 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_2, x_57, x_61);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_62, 1);
-lean_inc(x_64);
-lean_dec(x_62);
-x_3 = x_58;
-x_4 = x_64;
-goto _start;
-}
-else
-{
-uint8_t x_66; 
-lean_dec(x_58);
-lean_dec(x_1);
-x_66 = !lean_is_exclusive(x_62);
-if (x_66 == 0)
-{
-lean_object* x_67; uint8_t x_68; 
-x_67 = lean_ctor_get(x_62, 0);
-lean_dec(x_67);
-x_68 = !lean_is_exclusive(x_63);
-if (x_68 == 0)
-{
-return x_62;
-}
-else
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_63, 0);
-lean_inc(x_69);
-lean_dec(x_63);
-x_70 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_62, 0, x_70);
-return x_62;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_71 = lean_ctor_get(x_62, 1);
-lean_inc(x_71);
-lean_dec(x_62);
-x_72 = lean_ctor_get(x_63, 0);
-lean_inc(x_72);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- x_73 = x_63;
-} else {
- lean_dec_ref(x_63);
- x_73 = lean_box(0);
-}
-if (lean_is_scalar(x_73)) {
- x_74 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_74 = x_73;
-}
-lean_ctor_set(x_74, 0, x_72);
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_71);
-return x_75;
-}
-}
-}
-else
-{
-uint8_t x_76; 
-lean_dec(x_58);
-lean_dec(x_57);
-lean_dec(x_1);
-x_76 = !lean_is_exclusive(x_59);
-if (x_76 == 0)
-{
-lean_object* x_77; uint8_t x_78; 
-x_77 = lean_ctor_get(x_59, 0);
-lean_dec(x_77);
-x_78 = !lean_is_exclusive(x_60);
-if (x_78 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_60, 0);
-lean_inc(x_79);
-lean_dec(x_60);
-x_80 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_59, 0, x_80);
-return x_59;
-}
-}
-else
-{
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_81 = lean_ctor_get(x_59, 1);
-lean_inc(x_81);
-lean_dec(x_59);
-x_82 = lean_ctor_get(x_60, 0);
-lean_inc(x_82);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- x_83 = x_60;
-} else {
- lean_dec_ref(x_60);
- x_83 = lean_box(0);
-}
-if (lean_is_scalar(x_83)) {
- x_84 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_84 = x_83;
-}
-lean_ctor_set(x_84, 0, x_82);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_81);
-return x_85;
-}
-}
-}
-case 10:
-{
-lean_object* x_86; 
-x_86 = lean_ctor_get(x_3, 1);
-lean_inc(x_86);
-lean_dec(x_3);
-x_3 = x_86;
-x_4 = x_6;
-goto _start;
-}
-case 11:
-{
-lean_object* x_88; 
-x_88 = lean_ctor_get(x_3, 2);
-lean_inc(x_88);
-lean_dec(x_3);
-x_3 = x_88;
-x_4 = x_6;
-goto _start;
-}
-default: 
-{
-lean_object* x_90; lean_object* x_91; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_90 = lean_box(0);
-x_91 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_6);
-return x_91;
-}
-}
-}
+x_8 = 0;
+return x_8;
 }
 }
 }
 uint8_t l_Lean_Environment_hasUnsafe(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_3 = 8192;
-x_4 = l_Lean_Expr_FindImpl_initCache;
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_3, x_2, x_4);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-lean_dec(x_5);
-if (lean_obj_tag(x_6) == 0)
+lean_object* x_3; size_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Environment_hasUnsafe___lambda__1___boxed), 2, 1);
+lean_closure_set(x_3, 0, x_1);
+x_4 = 8192;
+x_5 = l_Lean_Expr_FindImpl_initCache;
+x_6 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_3, x_4, x_2, x_5);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_7) == 0)
 {
-uint8_t x_7; 
-x_7 = 0;
-return x_7;
+uint8_t x_8; 
+x_8 = 0;
+return x_8;
 }
 else
 {
-uint8_t x_8; 
-lean_dec(x_6);
-x_8 = 1;
-return x_8;
+uint8_t x_9; 
+lean_dec(x_7);
+x_9 = 1;
+return x_9;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Environment_hasUnsafe___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_5; lean_object* x_6; 
-x_5 = lean_unbox_usize(x_2);
-lean_dec(x_2);
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Environment_hasUnsafe___spec__1(x_1, x_5, x_3, x_4);
-return x_6;
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Lean_Environment_hasUnsafe___lambda__1(x_1, x_2);
+x_4 = lean_box(x_3);
+return x_4;
 }
 }
 lean_object* l_Lean_Environment_hasUnsafe___boxed(lean_object* x_1, lean_object* x_2) {
diff --git a/stage0/stdlib/Lean/Expr.c b/stage0/stdlib/Lean/Expr.c
index 9bcd19db17..88a07867e5 100644
--- a/stage0/stdlib/Lean/Expr.c
+++ b/stage0/stdlib/Lean/Expr.c
@@ -93,7 +93,6 @@ lean_object* l_Lean_mkMVar(lean_object*);
 lean_object* l_List_map___main___at_Lean_Expr_instantiateLevelParams___spec__4___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_hash___boxed(lean_object*);
 lean_object* l_Lean_Expr_betaRev___boxed(lean_object*, lean_object*);
-extern lean_object* l_Lean_verboseOption___closed__3;
 lean_object* l_Lean_Expr_mvarId_x21___boxed(lean_object*);
 lean_object* l___private_Lean_Expr_2__mkAppRangeAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Expr_5__withAppRevAux(lean_object*);
@@ -289,7 +288,6 @@ lean_object* l_Lean_Literal_type___closed__1;
 lean_object* lean_expr_abstract_range(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getArg_x21___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_bindingDomain_x21___closed__1;
-lean_object* l_Lean_KVMap_insertCore___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_InstantiateLevelParams_instantiate(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_ctorName___closed__3;
 lean_object* l_Lean_Expr_natLit_x3f(lean_object*);
@@ -431,6 +429,7 @@ extern uint8_t l_Bool_Inhabited;
 lean_object* l_Lean_Expr_bvarIdx_x21___closed__1;
 lean_object* l___private_Lean_Expr_4__getAppRevArgsAux(lean_object*, lean_object*);
 lean_object* lean_panic_fn(lean_object*, lean_object*);
+extern lean_object* l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3;
 lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isHeadBetaTargetFn___main(lean_object*);
 uint32_t l_USize_toUInt32(size_t);
@@ -441,6 +440,7 @@ uint64_t l_UInt64_shiftLeft(uint64_t, uint64_t);
 lean_object* l_Lean_Expr_binderInfo___boxed(lean_object*);
 lean_object* l___private_Lean_Expr_5__withAppRevAux___main(lean_object*);
 lean_object* l_Lean_Literal_lt___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_KVMap_insertCore(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_updateFn___main(lean_object*, lean_object*);
 lean_object* l_Lean_mkApp7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_updateLambda_x21___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -10799,8 +10799,8 @@ _start:
 {
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_3 = l_Lean_KVMap_empty;
-x_4 = l_Lean_verboseOption___closed__3;
-x_5 = l_Lean_KVMap_insertCore___main(x_3, x_1, x_4);
+x_4 = l_Lean_initFn____x40_Lean_Data_Options___hyg_481____closed__3;
+x_5 = l_Lean_KVMap_insertCore(x_3, x_1, x_4);
 x_6 = l_Lean_mkMData(x_5, x_2);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Hygiene.c b/stage0/stdlib/Lean/Hygiene.c
index 20a48f1222..f1f779ac89 100644
--- a/stage0/stdlib/Lean/Hygiene.c
+++ b/stage0/stdlib/Lean/Hygiene.c
@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* l_Lean_sanitizeSyntax(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Unhygienic_MonadQuotation___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Unhygienic_MonadQuotation___closed__3;
 lean_object* lean_erase_macro_scopes(lean_object*);
@@ -49,18 +48,19 @@ lean_object* l_Lean_Unhygienic_run___rarg(lean_object*);
 lean_object* l___private_Lean_Hygiene_1__mkInaccessibleUserNameAux(uint8_t, lean_object*, lean_object*);
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Unhygienic_MonadQuotation___closed__4;
+lean_object* l_Std_RBNode_find___at_Lean_sanitizeName___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Hygiene_2__mkInaccessibleUserName___main___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Hygiene_2__mkInaccessibleUserName___main___closed__1;
 lean_object* l_ReaderT_read___at_Lean_Unhygienic_MonadQuotation___spec__1(lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_sanitizeName___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Nat_toSuperscriptString(lean_object*);
 lean_object* l_Lean_sanitizeNamesOption___closed__4;
 lean_object* l___private_Lean_Hygiene_1__mkInaccessibleUserNameAux___closed__3;
 lean_object* l_Lean_Unhygienic_MonadQuotation___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_firstFrontendMacroScope;
-lean_object* l_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1(lean_object*, lean_object*);
 uint8_t lean_is_inaccessible_user_name(lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_sanitizeNamesOption___closed__6;
@@ -72,8 +72,8 @@ lean_object* l_Lean_Name_appendAfter(lean_object*, lean_object*);
 lean_object* l___private_Lean_Hygiene_2__mkInaccessibleUserName___main(uint8_t, lean_object*);
 lean_object* l_Lean_getSanitizeNames___boxed(lean_object*);
 lean_object* l_Lean_sanitizeNamesOption___closed__1;
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* lean_register_option(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l___private_Lean_Hygiene_3__mkFreshInaccessibleUserName___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Unhygienic_MonadQuotation___closed__2;
 uint8_t l_Lean_sanitizeNamesDefault;
@@ -658,7 +658,7 @@ x_4 = l___private_Lean_Hygiene_3__mkFreshInaccessibleUserName___main(x_1, x_2, x
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_sanitizeName___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -709,7 +709,7 @@ lean_inc(x_1);
 x_3 = lean_erase_macro_scopes(x_1);
 x_4 = lean_ctor_get(x_2, 1);
 lean_inc(x_4);
-x_5 = l_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1(x_4, x_3);
+x_5 = l_Std_RBNode_find___at_Lean_sanitizeName___spec__1(x_4, x_3);
 lean_dec(x_4);
 if (lean_obj_tag(x_5) == 0)
 {
@@ -877,11 +877,11 @@ return x_51;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_sanitizeName___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_sanitizeName___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -929,7 +929,7 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -1063,7 +1063,7 @@ lean_inc(x_27);
 lean_dec(x_1);
 x_28 = lean_ctor_get(x_2, 2);
 lean_inc(x_28);
-x_29 = l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_28, x_27);
+x_29 = l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_28, x_27);
 lean_dec(x_28);
 if (lean_obj_tag(x_29) == 0)
 {
@@ -1132,11 +1132,11 @@ return x_44;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/KeyedDeclsAttribute.c b/stage0/stdlib/Lean/KeyedDeclsAttribute.c
index b399a4daae..92c9bf5415 100644
--- a/stage0/stdlib/Lean/KeyedDeclsAttribute.c
+++ b/stage0/stdlib/Lean/KeyedDeclsAttribute.c
@@ -1597,54 +1597,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__10___rarg(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__10___rarg(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__10___rarg(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__14___rarg(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__14___rarg(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__14___rarg(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__14___rarg(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
@@ -2539,54 +2545,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__21___rarg(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__21___rarg(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__21___rarg(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__25___rarg(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__25___rarg(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__25___rarg(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_KeyedDeclsAttribute_Table_insert___spec__25___rarg(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
diff --git a/stage0/stdlib/Lean/Level.c b/stage0/stdlib/Lean/Level.c
index 6de106b475..14d290df04 100644
--- a/stage0/stdlib/Lean/Level.c
+++ b/stage0/stdlib/Lean/Level.c
@@ -28,7 +28,6 @@ lean_object* l___private_Lean_Level_5__mkMaxAux___main___boxed(lean_object*, lea
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_Level_normalize___main___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_unreachable_x21___rarg(lean_object*);
 size_t l_UInt32_toUSize(uint32_t);
-uint8_t l_Lean_Name_lt___main(lean_object*, lean_object*);
 lean_object* l_Lean_Level_isMVar___boxed(lean_object*);
 lean_object* l_Lean_Level_updateIMax___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Level_mkData___closed__3;
@@ -167,7 +166,6 @@ lean_object* l_Lean_Level_LevelToFormat_Result_format___main___closed__6;
 lean_object* l_Lean_Level_instantiateParams___main(lean_object*, lean_object*);
 lean_object* l_Lean_Level_getOffset___boxed(lean_object*);
 lean_object* l_Lean_mkLevelMVar(lean_object*);
-lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Level_normalize___boxed(lean_object*);
 lean_object* l_Nat_toLevel(lean_object*);
 uint8_t l_Lean_Level_normLt(lean_object*, lean_object*);
@@ -183,6 +181,7 @@ lean_object* l_Lean_levelOne___closed__1;
 lean_object* l_Lean_levelZero___closed__2;
 lean_object* l_Lean_Level_isMaxIMax___boxed(lean_object*);
 lean_object* l_Lean_Level_Hashable___closed__1;
+uint8_t l_Lean_Name_lt(lean_object*, lean_object*);
 uint32_t l_Lean_Level_Data_depth(uint64_t);
 lean_object* l_Lean_mkLevelSucc(lean_object*);
 lean_object* l___private_Lean_Level_3__getMaxArgsAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -259,6 +258,7 @@ uint8_t l_Lean_Level_isNeverZero___main(lean_object*);
 lean_object* lean_uint32_to_nat(uint32_t);
 lean_object* l_Lean_Level_HasBeq;
 uint64_t l_Lean_Level_Data_inhabited;
+lean_object* l_Lean_Name_replacePrefix(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Level_Data_hasParam___boxed(lean_object*);
 lean_object* l___private_Lean_Level_7__isExplicitSubsumedAux___main___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Level_updateIMax_x21___closed__2;
@@ -2188,7 +2188,7 @@ if (x_59 == 0)
 uint8_t x_60; 
 lean_dec(x_4);
 lean_dec(x_2);
-x_60 = l_Lean_Name_lt___main(x_57, x_58);
+x_60 = l_Lean_Name_lt(x_57, x_58);
 return x_60;
 }
 else
@@ -3976,7 +3976,7 @@ lean_inc(x_19);
 lean_dec(x_1);
 x_20 = l_Lean_NameGenerator_Inhabited___closed__2;
 x_21 = l_Lean_Level_LevelToFormat_toResult___main___closed__3;
-x_22 = l_Lean_Name_replacePrefix___main(x_19, x_20, x_21);
+x_22 = l_Lean_Name_replacePrefix(x_19, x_20, x_21);
 x_23 = l_Lean_fmt___at_Lean_Level_LevelToFormat_toResult___main___spec__1(x_22);
 x_24 = l_Lean_Level_LevelToFormat_toResult___main___closed__5;
 x_25 = lean_alloc_ctor(4, 2, 0);
diff --git a/stage0/stdlib/Lean/Meta/AbstractMVars.c b/stage0/stdlib/Lean/Meta/AbstractMVars.c
index 7a05bf60ab..b4772f03e7 100644
--- a/stage0/stdlib/Lean/Meta/AbstractMVars.c
+++ b/stage0/stdlib/Lean/Meta/AbstractMVars.c
@@ -16,6 +16,7 @@ extern "C" {
 lean_object* l_Std_AssocList_contains___at___private_Lean_Meta_AbstractMVars_0__Lean_Meta_AbstractMVars_abstractLevelMVars___spec__4___boxed(lean_object*, lean_object*);
 lean_object* l_Array_isEqvAux___main___at_Lean_Meta_AbstractMVarsResult_beq___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_expr_update_forall(lean_object*, uint8_t, lean_object*, lean_object*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Array_umapMAux___main___at_Lean_Meta_openAbstractMVarsResult___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___at_Lean_Meta_AbstractMVars_abstractExprMVars___spec__1(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_AssocList_contains___at_Lean_Meta_AbstractMVars_abstractExprMVars___spec__2(lean_object*, lean_object*);
@@ -119,7 +120,6 @@ lean_object* l_Lean_Meta_AbstractMVarsResult_beq___boxed(lean_object*, lean_obje
 lean_object* l_Lean_Meta_AbstractMVarsResult_hasBeq___closed__1;
 lean_object* l_Lean_Meta_abstractMVars_match__1(lean_object*);
 lean_object* lean_nat_mul(lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_AbstractMVars_State_lmap___default;
 extern lean_object* l_Lean_Expr_updateLet_x21___closed__1;
@@ -2409,7 +2409,7 @@ x_1 = l_Lean_Meta_AbstractMVars_abstractExprMVars___closed__3;
 x_2 = l_Lean_Meta_AbstractMVars_abstractExprMVars___closed__4;
 x_3 = lean_unsigned_to_nat(104u);
 x_4 = lean_unsigned_to_nat(20u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Meta/Basic.c b/stage0/stdlib/Lean/Meta/Basic.c
index 0bc10f5469..7b15706d11 100644
--- a/stage0/stdlib/Lean/Meta/Basic.c
+++ b/stage0/stdlib/Lean/Meta/Basic.c
@@ -45,6 +45,7 @@ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp__
 lean_object* l_Lean_Meta_instantiateLambda___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_instantiateLocalDeclMVars___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_setMVarKind___rarg(lean_object*, lean_object*, uint8_t);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewMCtxDepthImp___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_withLocalDecl(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAuxAux___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1328,7 +1329,6 @@ lean_object* l_Lean_Meta_assignExprMVar___rarg___lambda__1___boxed(lean_object*,
 lean_object* l_Lean_throwError___at_Lean_Meta_getMVarDecl___spec__1(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp___at___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeImp___spec__42___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Meta_mkFreshExprMVarWithId___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withNewLocalInstancesImp___at___private_Lean_Meta_Basic_0__Lean_Meta_forallTelescopeReducingImp___spec__89(lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_lambdaMetaTelescopeImp_process_match__1(lean_object*);
@@ -12839,7 +12839,7 @@ x_1 = l___private_Lean_Meta_Basic_0__Lean_Meta_isClassQuick_x3f___closed__2;
 x_2 = l___private_Lean_Meta_Basic_0__Lean_Meta_isClassQuick_x3f___closed__3;
 x_3 = lean_unsigned_to_nat(468u);
 x_4 = lean_unsigned_to_nat(25u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Meta/Check.c b/stage0/stdlib/Lean/Meta/Check.c
index c85557977a..a562515145 100644
--- a/stage0/stdlib/Lean/Meta/Check.c
+++ b/stage0/stdlib/Lean/Meta/Check.c
@@ -13,6 +13,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Lean_Meta_throwLetTypeMismatchMessage___rarg___closed__6;
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_check___closed__1;
@@ -123,7 +124,6 @@ lean_object* l_Array_umapMAux___main___at___private_Lean_Util_Trace_4__addNode__
 lean_object* l___private_Lean_Meta_Check_0__Lean_Meta_getFunctionDomain_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_Check_0__Lean_Meta_checkLambdaLet___at___private_Lean_Meta_Check_0__Lean_Meta_checkAux___spec__3___closed__1;
 lean_object* l_Lean_throwError___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_refTrans___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_throwAppTypeMismatch___rarg___lambda__1___closed__3;
@@ -303,7 +303,7 @@ x_1 = l_Lean_Meta_throwLetTypeMismatchMessage___rarg___closed__1;
 x_2 = l_Lean_Meta_throwLetTypeMismatchMessage___rarg___closed__2;
 x_3 = lean_unsigned_to_nat(27u);
 x_4 = lean_unsigned_to_nat(7u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Meta/DiscrTree.c b/stage0/stdlib/Lean/Meta/DiscrTree.c
index 04a7d6dc5f..091c55f9cf 100644
--- a/stage0/stdlib/Lean/Meta/DiscrTree.c
+++ b/stage0/stdlib/Lean/Meta/DiscrTree.c
@@ -16,7 +16,6 @@ extern "C" {
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getMatch___spec__10(lean_object*);
 lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_Meta_DiscrTree_getMatch___spec__8___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_Meta_DiscrTree_getMatch___spec__2___rarg(lean_object*, size_t, lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_Meta_DiscrTree_format___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_binSearchAux___main___at___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getMatchAux___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___main___at_Lean_Meta_DiscrTree_Trie_format___spec__2(lean_object*);
@@ -85,6 +84,7 @@ lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Std_PersistentHashMap_findAux___main___at___private_Lean_Meta_DiscrTree_0__Lean_Meta_DiscrTree_getStarResult___spec__2___rarg(lean_object*, size_t, lean_object*);
 lean_object* l_Std_PersistentHashMap_getCollisionNodeSize___rarg(lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_Meta_DiscrTree_getUnify___spec__10(lean_object*);
 lean_object* l_Lean_Meta_DiscrTree_Key_ctorIdx___boxed(lean_object*);
 lean_object* l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_DiscrTree_getUnify___spec__4(lean_object*);
@@ -1015,7 +1015,7 @@ lean_object* x_7; lean_object* x_8;
 x_7 = lean_ctor_get(x_6, 0);
 lean_inc(x_7);
 lean_dec(x_6);
-x_8 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_7);
+x_8 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_7);
 return x_8;
 }
 else
diff --git a/stage0/stdlib/Lean/Meta/ExprDefEq.c b/stage0/stdlib/Lean/Meta/ExprDefEq.c
index d50ae25919..c28f92fd62 100644
--- a/stage0/stdlib/Lean/Meta/ExprDefEq.c
+++ b/stage0/stdlib/Lean/Meta/ExprDefEq.c
@@ -26,6 +26,7 @@ lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_processConstApprox_mat
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_trySynthPending_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_processAssignmentFOApprox_loop___closed__2;
 lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_916____spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_isListLevelDefEq___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Std_PersistentArray_foldlM___at_Lean_withNestedTraces___spec__1(lean_object*, lean_object*);
@@ -508,7 +509,6 @@ lean_object* l_Lean_Meta_commitWhen___at___private_Lean_Meta_ExprDefEq_0__Lean_M
 lean_object* l_Lean_Meta_isEtaUnassignedMVar_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_trySynthPending___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_isLevelDefEqAux___closed__3;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_refTrans___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_ExprDefEq_0__Lean_Meta_isSynthetic_match__1(lean_object*);
@@ -27185,7 +27185,7 @@ x_1 = l_Lean_Meta_CheckAssignment_check___closed__3;
 x_2 = l_Lean_Meta_CheckAssignment_check___closed__4;
 x_3 = lean_unsigned_to_nat(519u);
 x_4 = lean_unsigned_to_nat(30u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -29980,7 +29980,7 @@ x_1 = l_Lean_Meta_CheckAssignment_check___closed__3;
 x_2 = l_Lean_Meta_CheckAssignmentQuick_check_visit___closed__1;
 x_3 = lean_unsigned_to_nat(597u);
 x_4 = lean_unsigned_to_nat(22u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Meta/InferType.c b/stage0/stdlib/Lean/Meta/InferType.c
index a22f1a8fb3..080507d36d 100644
--- a/stage0/stdlib/Lean/Meta/InferType.c
+++ b/stage0/stdlib/Lean/Meta/InferType.c
@@ -21,6 +21,7 @@ lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_inferFVarType_match__1
 lean_object* l_Lean_Meta_isPropQuick_match__1(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_916____spec__1___rarg(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_Level_normalize___main(lean_object*);
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_InferType_0__Lean_Meta_inferProjType___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_InferType_0__Lean_Meta_inferProjType___spec__1___closed__2;
@@ -211,7 +212,6 @@ lean_object* l_Lean_Meta_getLevel(lean_object*);
 lean_object* l_Lean_Meta_setMCtx___at___private_Lean_Meta_Basic_0__Lean_Meta_liftMkBindingM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isProofQuick_match__1___rarg(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_metavar_ctx_find_decl(lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_InferType_0__Lean_Meta_isTypeFormerTypeImp_match__2___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isTypeFormerType___at_Lean_Meta_isTypeFormer___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -5710,7 +5710,7 @@ x_1 = l___private_Lean_Meta_InferType_0__Lean_Meta_inferTypeAux___closed__3;
 x_2 = l___private_Lean_Meta_InferType_0__Lean_Meta_inferTypeAux___closed__4;
 x_3 = lean_unsigned_to_nat(142u);
 x_4 = lean_unsigned_to_nat(30u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -8889,7 +8889,7 @@ x_1 = l___private_Lean_Meta_InferType_0__Lean_Meta_inferTypeAux___closed__3;
 x_2 = l_Lean_Meta_isPropQuick___closed__1;
 x_3 = lean_unsigned_to_nat(203u);
 x_4 = lean_unsigned_to_nat(27u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -10566,7 +10566,7 @@ x_1 = l___private_Lean_Meta_InferType_0__Lean_Meta_inferTypeAux___closed__3;
 x_2 = l_Lean_Meta_isProofQuick___closed__1;
 x_3 = lean_unsigned_to_nat(268u);
 x_4 = lean_unsigned_to_nat(27u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -12074,7 +12074,7 @@ x_1 = l___private_Lean_Meta_InferType_0__Lean_Meta_inferTypeAux___closed__3;
 x_2 = l_Lean_Meta_isTypeQuick___closed__1;
 x_3 = lean_unsigned_to_nat(325u);
 x_4 = lean_unsigned_to_nat(27u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Meta/LevelDefEq.c b/stage0/stdlib/Lean/Meta/LevelDefEq.c
index 2c2bf6d783..36aaf7d1ec 100644
--- a/stage0/stdlib/Lean/Meta/LevelDefEq.c
+++ b/stage0/stdlib/Lean/Meta/LevelDefEq.c
@@ -13,7 +13,6 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l___private_Lean_Util_Trace_5__getResetTraces___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponed___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_decAux_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__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*);
@@ -68,6 +67,7 @@ lean_object* l_ReaderT_bind___at_Lean_Meta_Lean_Meta_Basic___instance__5___spec_
 lean_object* l_Lean_Meta_decLevel___rarg___lambda__1___closed__4;
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Lean_Meta_isLevelDefEq___rarg___closed__3;
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l___private_Lean_Util_Trace_5__getResetTraces___at_Lean_Meta_isLevelDefEq___spec__3(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_decAux_x3f_match__3(lean_object*);
 lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedStep___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -14814,7 +14814,7 @@ else
 {
 lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
 lean_inc(x_9);
-x_113 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_9);
+x_113 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_9);
 x_114 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_114, 0, x_113);
 x_115 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedAux___rarg___closed__4;
@@ -15177,7 +15177,7 @@ else
 {
 lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; 
 lean_inc(x_137);
-x_198 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_137);
+x_198 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_137);
 x_199 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_199, 0, x_198);
 x_200 = l___private_Lean_Meta_LevelDefEq_0__Lean_Meta_processPostponedAux___rarg___closed__4;
diff --git a/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c b/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c
index d330e78f0b..f487681544 100644
--- a/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c
+++ b/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c
@@ -35,15 +35,14 @@ lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_
 lean_object* l_Lean_Meta_MVarRenaming_find_x21___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM___main___at_Lean_Meta_MVarRenaming_apply___spec__1(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_MVarRenaming_apply_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_MVarRenaming_find_x3f___boxed(lean_object*, lean_object*);
 lean_object* lean_expr_update_let(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_Data_binderInfo(uint64_t);
 lean_object* lean_expr_update_proj(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_MVarRenaming_isEmpty___boxed(lean_object*);
 lean_object* l_Lean_Meta_MVarRenaming_apply___boxed(lean_object*, lean_object*);
 size_t l_USize_mod(size_t, size_t);
+lean_object* l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(lean_object*, lean_object*);
 size_t lean_ptr_addr(lean_object*);
 lean_object* l_Lean_Meta_MVarRenaming_find_x21(lean_object*, lean_object*);
 uint8_t l_Lean_Expr_hasMVar(lean_object*);
@@ -52,6 +51,7 @@ lean_object* l_Lean_Meta_MVarRenaming_apply_match__2(lean_object*);
 lean_object* lean_expr_update_lambda(lean_object*, uint8_t, lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM___main___closed__1;
 lean_object* lean_expr_update_app(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_ReplaceImpl_initCache;
 static lean_object* _init_l_Lean_Meta_MVarRenaming_map___default() {
 _start:
@@ -88,7 +88,7 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -135,15 +135,15 @@ lean_object* l_Lean_Meta_MVarRenaming_find_x3f(lean_object* x_1, lean_object* x_
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_2);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -163,7 +163,7 @@ lean_object* l_Lean_Meta_MVarRenaming_find_x21(lean_object* x_1, lean_object* x_
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_2);
 if (lean_obj_tag(x_3) == 0)
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; 
@@ -282,7 +282,7 @@ if (lean_obj_tag(x_3) == 2)
 lean_object* x_170; lean_object* x_171; 
 x_170 = lean_ctor_get(x_3, 0);
 lean_inc(x_170);
-x_171 = l_Std_RBNode_find___main___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_170);
+x_171 = l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_170);
 lean_dec(x_170);
 if (lean_obj_tag(x_171) == 0)
 {
diff --git a/stage0/stdlib/Lean/Meta/Match/Match.c b/stage0/stdlib/Lean/Meta/Match/Match.c
index 2835c5c4f5..f0538b3362 100644
--- a/stage0/stdlib/Lean/Meta/Match/Match.c
+++ b/stage0/stdlib/Lean/Meta/Match/Match.c
@@ -22,7 +22,6 @@ lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processAsPatte
 lean_object* l_Lean_Meta_withExistingLocalDecls___at_Lean_Meta_Match_Alt_toMessageData___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_mkHole___closed__3;
 lean_object* l_Lean_Meta_Match_Example_applyFVarSubst_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_Meta_Match_mkMatcher___lambda__2___closed__1;
 lean_object* l_Lean_Meta_Match_Example_applyFVarSubst(lean_object*, lean_object*);
 lean_object* l_List_mapM___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAltsAux___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -42,6 +41,7 @@ lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hy
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processConstructor_match__4(lean_object*);
 lean_object* l_Lean_Meta_Match_mkMatcher___lambda__1___closed__3;
 size_t l_USize_add(size_t, size_t);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processSkipInaccessible___spec__1___closed__3;
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_Meta_Match_processInaccessibleAsCtor_match__2(lean_object*);
@@ -81,7 +81,6 @@ lean_object* l_Lean_Meta_isExprDefEq___at_Lean_Meta_isExprDefEqGuarded___spec__1
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_throwInductiveTypeExpected(lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_updateAlts___lambda__3___closed__2;
 extern lean_object* l_Lean_MessageData_ofList___closed__3;
-uint8_t l_USize_decEq(size_t, size_t);
 lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_collectArraySizes_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_mkMatcher___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -196,6 +195,7 @@ lean_object* l_Lean_Meta_Match_Problem_toMessageData___lambda__1___closed__8;
 lean_object* l_Lean_addTrace___at_Lean_Meta_Match_Unify_assign___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processValue___spec__3(lean_object*, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 uint8_t l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_hasNatValPattern(lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_hasCtorPattern_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MessageData_ofList(lean_object*);
@@ -332,7 +332,6 @@ lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAltsAux___
 lean_object* l_Lean_Meta_Match_Pattern_toMessageData___closed__5;
 lean_object* l_List_filterMapMAux___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processConstructor___spec__8___closed__2;
 lean_object* l_Lean_Meta_Match_Problem_toMessageData___lambda__1___closed__9;
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_Pattern_toMessageData(lean_object*);
 lean_object* l_Lean_Meta_Match_Example_varsToUnderscore(lean_object*);
 lean_object* l_Lean_Meta_Match_Unify_unify_match__1(lean_object*);
@@ -488,6 +487,7 @@ lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_hasCtorPattern
 extern lean_object* l_Array_iterateMAux___main___at_Lean_ppGoal___spec__6___closed__6;
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_getUElimPos_x3f___closed__2;
 uint8_t l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_isFirstPatternVar(lean_object*);
+uint8_t l_Lean_Meta_Match_Unify_occurs___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_matchMatcherApp_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_CoreM_1__mkFreshNameImp(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processNonVariable_match__2___rarg(lean_object*, lean_object*, lean_object*);
@@ -596,7 +596,6 @@ lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processLeaf_ma
 lean_object* l_Lean_Meta_Match_isCurrVarInductive___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_Alt_Lean_Meta_Match_Match___instance__2;
 lean_object* l_Std_HashMapImp_find_x3f___at_Lean_Meta_Match_Extension_getMatcherInfo_x3f___spec__5___boxed(lean_object*, lean_object*);
-size_t l_USize_mod(size_t, size_t);
 lean_object* l_Lean_Meta_Match_Extension_mkExtension___closed__2;
 lean_object* l_Lean_Meta_Match_Unify_assign___closed__2;
 lean_object* l_Lean_LocalDecl_type(lean_object*);
@@ -617,7 +616,6 @@ lean_object* l_Lean_Meta_Match_mkMatcher___lambda__1___closed__12;
 lean_object* l_List_map___main___at_Lean_Meta_Match_examplesToMessageData___spec__1(lean_object*);
 lean_object* l_Lean_Meta_getMatcherInfo_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Util_Trace_4__addNode___at_Lean_Meta_isLevelDefEq___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-size_t lean_ptr_addr(lean_object*);
 lean_object* l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processArrayLit___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Std_HashSetImp_expand___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processLeaf___spec__2(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_expandVarIntoArrayLit_loop_match__1(lean_object*);
@@ -737,7 +735,6 @@ lean_object* lean_nat_mul(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processLeaf___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_traceState(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_Example_varsToUnderscore_match__1(lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processArrayLit_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_throwErrorAt___at_Lean_Meta_Match_Alt_checkAndReplaceFVarId___spec__1(lean_object*);
 uint8_t l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_isNatValueTransition(lean_object*);
@@ -837,8 +834,10 @@ lean_object* l_Lean_EnumAttributes_setValue___rarg(lean_object*, lean_object*, l
 lean_object* l_Lean_Meta_Match_examplesToMessageData(lean_object*);
 lean_object* l_Lean_Meta_instantiateMVars___at_Lean_Meta_instantiateLocalDeclMVars___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_Alt_checkAndReplaceFVarId___closed__9;
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_State_used___default;
 lean_object* l_Lean_Meta_Match_Alt_checkAndReplaceFVarId___closed__8;
+lean_object* l_Lean_Meta_Match_Unify_occurs___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_List_mapM___main___at_Lean_Meta_Match_Problem_toMessageData___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_instantiateLambdaAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Meta_isLevelDefEqAux___closed__5;
@@ -924,7 +923,6 @@ lean_object* l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta
 lean_object* l_Lean_Meta_Match_Alt_checkAndReplaceFVarId___closed__2;
 lean_object* l_Lean_Meta_forallBoundedTelescope___at___private_Lean_Meta_FunInfo_0__Lean_Meta_getFunInfoAux___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_Match_counterExamplesToMessageData(lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_caseArraySizes(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_Match_Example_toMessageData___closed__1;
 lean_object* l_Lean_Meta_MatcherApp_addArg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -8661,7 +8659,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processSkipInaccessible___spec__1___closed__2;
 x_3 = lean_unsigned_to_nat(359u);
 x_4 = lean_unsigned_to_nat(17u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -9005,7 +9003,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processSkipInaccessible___spec__1___closed__2;
 x_3 = lean_unsigned_to_nat(355u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -10095,7 +10093,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processAsPattern___closed__1;
 x_3 = lean_unsigned_to_nat(374u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -10269,7 +10267,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_mapM___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processVariable___spec__1___closed__1;
 x_3 = lean_unsigned_to_nat(388u);
 x_4 = lean_unsigned_to_nat(38u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -10688,7 +10686,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_mapM___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processVariable___spec__1___closed__1;
 x_3 = lean_unsigned_to_nat(383u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -11036,526 +11034,60 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Meta_Match_Unify_occurs_match__1___rarg)
 return x_2;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
+uint8_t l_Lean_Meta_Match_Unify_occurs___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; size_t x_102; size_t x_103; lean_object* x_104; size_t x_105; uint8_t x_106; 
-x_102 = lean_ptr_addr(x_3);
-x_103 = x_2 == 0 ? 0 : x_102 % x_2;
-x_104 = lean_array_uget(x_4, x_103);
-x_105 = lean_ptr_addr(x_104);
-lean_dec(x_104);
-x_106 = x_105 == x_102;
-if (x_106 == 0)
+if (lean_obj_tag(x_2) == 1)
 {
-lean_object* x_107; uint8_t x_108; 
-lean_inc(x_3);
-x_107 = lean_array_uset(x_4, x_103, x_3);
-x_108 = 0;
-x_5 = x_108;
-x_6 = x_107;
-goto block_101;
+lean_object* x_3; uint8_t x_4; 
+x_3 = lean_ctor_get(x_2, 0);
+x_4 = lean_name_eq(x_1, x_3);
+return x_4;
 }
 else
 {
-uint8_t x_109; 
-x_109 = 1;
-x_5 = x_109;
-x_6 = x_4;
-goto block_101;
-}
-block_101:
-{
-lean_object* x_7; 
-if (x_5 == 0)
-{
-if (lean_obj_tag(x_3) == 1)
-{
-lean_object* x_93; uint8_t x_94; 
-x_93 = lean_ctor_get(x_3, 0);
-lean_inc(x_93);
-x_94 = lean_name_eq(x_1, x_93);
-lean_dec(x_93);
-if (x_94 == 0)
-{
-lean_object* x_95; 
-x_95 = lean_box(0);
-x_7 = x_95;
-goto block_92;
-}
-else
-{
-lean_object* x_96; lean_object* x_97; 
-x_96 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_96, 0, x_3);
-x_97 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_97, 0, x_96);
-lean_ctor_set(x_97, 1, x_6);
-return x_97;
-}
-}
-else
-{
-lean_object* x_98; 
-x_98 = lean_box(0);
-x_7 = x_98;
-goto block_92;
-}
-}
-else
-{
-lean_object* x_99; lean_object* x_100; 
-lean_dec(x_3);
-x_99 = lean_box(0);
-x_100 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_100, 0, x_99);
-lean_ctor_set(x_100, 1, x_6);
-return x_100;
-}
-block_92:
-{
-lean_dec(x_7);
-switch (lean_obj_tag(x_3)) {
-case 5:
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-lean_dec(x_3);
-x_10 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(x_1, x_2, x_8, x_6);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-lean_dec(x_10);
-x_3 = x_9;
-x_4 = x_12;
-goto _start;
-}
-else
-{
-uint8_t x_14; 
-lean_dec(x_9);
-x_14 = !lean_is_exclusive(x_10);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_10, 0);
-lean_dec(x_15);
-x_16 = !lean_is_exclusive(x_11);
-if (x_16 == 0)
-{
-return x_10;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-x_17 = lean_ctor_get(x_11, 0);
-lean_inc(x_17);
-lean_dec(x_11);
-x_18 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_10, 0, x_18);
-return x_10;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_10, 1);
-lean_inc(x_19);
-lean_dec(x_10);
-x_20 = lean_ctor_get(x_11, 0);
-lean_inc(x_20);
-if (lean_is_exclusive(x_11)) {
- lean_ctor_release(x_11, 0);
- x_21 = x_11;
-} else {
- lean_dec_ref(x_11);
- x_21 = lean_box(0);
-}
-if (lean_is_scalar(x_21)) {
- x_22 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_22 = x_21;
-}
-lean_ctor_set(x_22, 0, x_20);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_22);
-lean_ctor_set(x_23, 1, x_19);
-return x_23;
-}
-}
-}
-case 6:
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = lean_ctor_get(x_3, 1);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_3, 2);
-lean_inc(x_25);
-lean_dec(x_3);
-x_26 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(x_1, x_2, x_24, x_6);
-x_27 = lean_ctor_get(x_26, 0);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; 
-x_28 = lean_ctor_get(x_26, 1);
-lean_inc(x_28);
-lean_dec(x_26);
-x_3 = x_25;
-x_4 = x_28;
-goto _start;
-}
-else
-{
-uint8_t x_30; 
-lean_dec(x_25);
-x_30 = !lean_is_exclusive(x_26);
-if (x_30 == 0)
-{
-lean_object* x_31; uint8_t x_32; 
-x_31 = lean_ctor_get(x_26, 0);
-lean_dec(x_31);
-x_32 = !lean_is_exclusive(x_27);
-if (x_32 == 0)
-{
-return x_26;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_27, 0);
-lean_inc(x_33);
-lean_dec(x_27);
-x_34 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_34, 0, x_33);
-lean_ctor_set(x_26, 0, x_34);
-return x_26;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_35 = lean_ctor_get(x_26, 1);
-lean_inc(x_35);
-lean_dec(x_26);
-x_36 = lean_ctor_get(x_27, 0);
-lean_inc(x_36);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- x_37 = x_27;
-} else {
- lean_dec_ref(x_27);
- x_37 = lean_box(0);
-}
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_38 = x_37;
-}
-lean_ctor_set(x_38, 0, x_36);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_35);
-return x_39;
-}
-}
-}
-case 7:
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_40 = lean_ctor_get(x_3, 1);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_3, 2);
-lean_inc(x_41);
-lean_dec(x_3);
-x_42 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(x_1, x_2, x_40, x_6);
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; 
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_3 = x_41;
-x_4 = x_44;
-goto _start;
-}
-else
-{
-uint8_t x_46; 
-lean_dec(x_41);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_42, 0);
-lean_dec(x_47);
-x_48 = !lean_is_exclusive(x_43);
-if (x_48 == 0)
-{
-return x_42;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; 
-x_49 = lean_ctor_get(x_43, 0);
-lean_inc(x_49);
-lean_dec(x_43);
-x_50 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_42, 0, x_50);
-return x_42;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_51 = lean_ctor_get(x_42, 1);
-lean_inc(x_51);
-lean_dec(x_42);
-x_52 = lean_ctor_get(x_43, 0);
-lean_inc(x_52);
-if (lean_is_exclusive(x_43)) {
- lean_ctor_release(x_43, 0);
- x_53 = x_43;
-} else {
- lean_dec_ref(x_43);
- x_53 = lean_box(0);
-}
-if (lean_is_scalar(x_53)) {
- x_54 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_54 = x_53;
-}
-lean_ctor_set(x_54, 0, x_52);
-x_55 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_51);
-return x_55;
-}
-}
-}
-case 8:
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_56 = lean_ctor_get(x_3, 1);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_3, 2);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_3, 3);
-lean_inc(x_58);
-lean_dec(x_3);
-x_59 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(x_1, x_2, x_56, x_6);
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_59, 1);
-lean_inc(x_61);
-lean_dec(x_59);
-x_62 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(x_1, x_2, x_57, x_61);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_62, 1);
-lean_inc(x_64);
-lean_dec(x_62);
-x_3 = x_58;
-x_4 = x_64;
-goto _start;
-}
-else
-{
-uint8_t x_66; 
-lean_dec(x_58);
-x_66 = !lean_is_exclusive(x_62);
-if (x_66 == 0)
-{
-lean_object* x_67; uint8_t x_68; 
-x_67 = lean_ctor_get(x_62, 0);
-lean_dec(x_67);
-x_68 = !lean_is_exclusive(x_63);
-if (x_68 == 0)
-{
-return x_62;
-}
-else
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_63, 0);
-lean_inc(x_69);
-lean_dec(x_63);
-x_70 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_62, 0, x_70);
-return x_62;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_71 = lean_ctor_get(x_62, 1);
-lean_inc(x_71);
-lean_dec(x_62);
-x_72 = lean_ctor_get(x_63, 0);
-lean_inc(x_72);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- x_73 = x_63;
-} else {
- lean_dec_ref(x_63);
- x_73 = lean_box(0);
-}
-if (lean_is_scalar(x_73)) {
- x_74 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_74 = x_73;
-}
-lean_ctor_set(x_74, 0, x_72);
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_71);
-return x_75;
-}
-}
-}
-else
-{
-uint8_t x_76; 
-lean_dec(x_58);
-lean_dec(x_57);
-x_76 = !lean_is_exclusive(x_59);
-if (x_76 == 0)
-{
-lean_object* x_77; uint8_t x_78; 
-x_77 = lean_ctor_get(x_59, 0);
-lean_dec(x_77);
-x_78 = !lean_is_exclusive(x_60);
-if (x_78 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_60, 0);
-lean_inc(x_79);
-lean_dec(x_60);
-x_80 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_59, 0, x_80);
-return x_59;
-}
-}
-else
-{
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_81 = lean_ctor_get(x_59, 1);
-lean_inc(x_81);
-lean_dec(x_59);
-x_82 = lean_ctor_get(x_60, 0);
-lean_inc(x_82);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- x_83 = x_60;
-} else {
- lean_dec_ref(x_60);
- x_83 = lean_box(0);
-}
-if (lean_is_scalar(x_83)) {
- x_84 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_84 = x_83;
-}
-lean_ctor_set(x_84, 0, x_82);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_81);
-return x_85;
-}
-}
-}
-case 10:
-{
-lean_object* x_86; 
-x_86 = lean_ctor_get(x_3, 1);
-lean_inc(x_86);
-lean_dec(x_3);
-x_3 = x_86;
-x_4 = x_6;
-goto _start;
-}
-case 11:
-{
-lean_object* x_88; 
-x_88 = lean_ctor_get(x_3, 2);
-lean_inc(x_88);
-lean_dec(x_3);
-x_3 = x_88;
-x_4 = x_6;
-goto _start;
-}
-default: 
-{
-lean_object* x_90; lean_object* x_91; 
-lean_dec(x_3);
-x_90 = lean_box(0);
-x_91 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_6);
-return x_91;
-}
-}
-}
+uint8_t x_5; 
+x_5 = 0;
+return x_5;
 }
 }
 }
 uint8_t l_Lean_Meta_Match_Unify_occurs(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_3 = 8192;
-x_4 = l_Lean_Expr_FindImpl_initCache;
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(x_1, x_3, x_2, x_4);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-lean_dec(x_5);
-if (lean_obj_tag(x_6) == 0)
+lean_object* x_3; size_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Meta_Match_Unify_occurs___lambda__1___boxed), 2, 1);
+lean_closure_set(x_3, 0, x_1);
+x_4 = 8192;
+x_5 = l_Lean_Expr_FindImpl_initCache;
+x_6 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_3, x_4, x_2, x_5);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_7) == 0)
 {
-uint8_t x_7; 
-x_7 = 0;
-return x_7;
+uint8_t x_8; 
+x_8 = 0;
+return x_8;
 }
 else
 {
-uint8_t x_8; 
-lean_dec(x_6);
-x_8 = 1;
-return x_8;
+uint8_t x_9; 
+lean_dec(x_7);
+x_9 = 1;
+return x_9;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Meta_Match_Unify_occurs___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_5; lean_object* x_6; 
-x_5 = lean_unbox_usize(x_2);
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Lean_Meta_Match_Unify_occurs___lambda__1(x_1, x_2);
 lean_dec(x_2);
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Meta_Match_Unify_occurs___spec__1(x_1, x_5, x_3, x_4);
 lean_dec(x_1);
-return x_6;
+x_4 = lean_box(x_3);
+return x_4;
 }
 }
 lean_object* l_Lean_Meta_Match_Unify_occurs___boxed(lean_object* x_1, lean_object* x_2) {
@@ -11563,7 +11095,6 @@ _start:
 {
 uint8_t x_3; lean_object* x_4; 
 x_3 = l_Lean_Meta_Match_Unify_occurs(x_1, x_2);
-lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
@@ -11816,6 +11347,7 @@ _start:
 {
 uint8_t x_10; 
 lean_inc(x_2);
+lean_inc(x_1);
 x_10 = l_Lean_Meta_Match_Unify_occurs(x_1, x_2);
 if (x_10 == 0)
 {
@@ -16699,7 +16231,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_Lean_Meta_Match_processInaccessibleAsCtor___closed__1;
 x_3 = lean_unsigned_to_nat(529u);
 x_4 = lean_unsigned_to_nat(7u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -17999,7 +17531,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_filterMapMAux___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processConstructor___spec__8___closed__1;
 x_3 = lean_unsigned_to_nat(574u);
 x_4 = lean_unsigned_to_nat(46u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -18572,7 +18104,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_filterMapMAux___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processConstructor___spec__8___closed__1;
 x_3 = lean_unsigned_to_nat(535u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -19072,7 +18604,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_filterMapMAux___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processNonVariable___spec__1___closed__1;
 x_3 = lean_unsigned_to_nat(593u);
 x_4 = lean_unsigned_to_nat(19u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -19598,7 +19130,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_filterMapMAux___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processNonVariable___spec__1___closed__1;
 x_3 = lean_unsigned_to_nat(579u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -20415,7 +19947,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processValue___spec__6___closed__1;
 x_3 = lean_unsigned_to_nat(633u);
 x_4 = lean_unsigned_to_nat(16u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -21025,7 +20557,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processValue___spec__6___closed__1;
 x_3 = lean_unsigned_to_nat(612u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -22608,7 +22140,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_mapM___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processArrayLit___spec__8___closed__1;
 x_3 = lean_unsigned_to_nat(688u);
 x_4 = lean_unsigned_to_nat(16u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -23308,7 +22840,7 @@ x_1 = l_List_map___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_
 x_2 = l_List_mapM___main___at___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_processArrayLit___spec__8___closed__1;
 x_3 = lean_unsigned_to_nat(666u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -27219,54 +26751,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_Meta_Match_Extension_State_addEntry___spec__2(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_Meta_Match_Extension_State_addEntry___spec__2(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_Meta_Match_Extension_State_addEntry___spec__2(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_Meta_Match_Extension_State_addEntry___spec__6(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_Meta_Match_Extension_State_addEntry___spec__6(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_Meta_Match_Extension_State_addEntry___spec__6(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_Meta_Match_Extension_State_addEntry___spec__6(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
@@ -33685,7 +33223,7 @@ lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_14 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_12);
+x_14 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_12);
 x_15 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_15, 0, x_14);
 x_16 = l_Lean_Meta_MatcherApp_addArg___lambda__4___closed__2;
diff --git a/stage0/stdlib/Lean/Meta/RecursorInfo.c b/stage0/stdlib/Lean/Meta/RecursorInfo.c
index 37372c3305..c976204012 100644
--- a/stage0/stdlib/Lean/Meta/RecursorInfo.c
+++ b/stage0/stdlib/Lean/Meta/RecursorInfo.c
@@ -15,7 +15,7 @@ extern "C" {
 #endif
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_recursorAttribute;
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___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* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getNumParams___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_brecOnSuffix___closed__1;
 lean_object* l_Lean_Meta_binductionOnSuffix;
@@ -36,9 +36,7 @@ lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getIndicesPos_match
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosIfAuxRecursor_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isExprDefEq___at_Lean_Meta_isExprDefEqGuarded___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____closed__4;
-uint8_t l_USize_decEq(size_t, size_t);
 lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___closed__15;
-lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getParamsPos_match__1(lean_object*);
 extern lean_object* l_List_repr___rarg___closed__1;
 extern lean_object* l_Option_HasRepr___rarg___closed__1;
@@ -53,8 +51,8 @@ uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_isMinor___boxed(lean_object*, lean_object*);
-lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 lean_object* l_Lean_Meta_inferType___at___private_Lean_Meta_InferType_0__Lean_Meta_inferAppType___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkRecursorInfo_match__2(lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotive___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoCore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -67,8 +65,8 @@ lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___clo
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Array_empty___closed__1;
-lean_object* l_Std_RBNode_fold___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3___boxed(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotive___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getParamsPos_match__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -79,6 +77,7 @@ lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim_
 uint8_t l_Lean_Meta_RecursorInfo_isMinor(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_recOnSuffix;
 lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___closed__7;
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotive___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotiveResultType___closed__1;
@@ -88,6 +87,7 @@ extern lean_object* l_Lean_getConstInfoRec___rarg___lambda__1___closed__3;
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_List_map___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoForKernelRec___spec__3(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_List_range(lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___closed__4;
 extern lean_object* l_Lean_Name_inhabited;
@@ -100,14 +100,15 @@ lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___clo
 lean_object* l_Lean_getConstInfoInduct___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoForKernelRec___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__3;
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__8___closed__2;
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkRecursorInfo_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___closed__8;
 extern lean_object* l_Lean_auxRecExt;
+lean_object* l_Lean_Expr_occurs___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMotiveLevel___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Data_Format_10__pushNewline___closed__1;
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___closed__1;
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_findIdxAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Environment_8__persistentEnvExtensionsRef;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive_match__1___rarg(lean_object*, lean_object*);
@@ -122,6 +123,7 @@ lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim_
 lean_object* l_Array_findIdxAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getUnivLevelPos___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_numParams___boxed(lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___closed__2;
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_ULift_HasRepr___rarg___closed__2;
 lean_object* l_Lean_throwError___at_Lean_Meta_getMVarDecl___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getConstInfoRec___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosIfAuxRecursor_x3f___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -129,11 +131,9 @@ lean_object* l_Lean_RecursorVal_getMajorIdx(lean_object*);
 lean_object* l_List_map___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoForKernelRec___spec__2(lean_object*);
 lean_object* l_Lean_Meta_brecOnSuffix;
 lean_object* l_Lean_Meta_RecursorUnivLevelPos_hasToString_match__1___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(lean_object*, lean_object*);
 extern lean_object* l_Std_Range_myMacro____x40_Init_Data_Range___hyg_301____closed__28;
 lean_object* lean_array_fget(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_numMinors(lean_object*);
-lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___closed__4;
 lean_object* l_Lean_Meta_getMajorPos_x3f(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
@@ -141,7 +141,6 @@ lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_Rec
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotive___closed__3;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__6(lean_object*, lean_object*);
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__8___boxed(lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_syntaxToMajorPos(lean_object*);
@@ -181,6 +180,7 @@ lean_object* l_Lean_ConstantInfo_name(lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getUnivLevelPos_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerParametricAttribute___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__2___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoForKernelRec(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_sanitizeName___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___spec__1___closed__2;
 lean_object* l_Lean_Meta_mkBInductionOnFor(lean_object*);
 lean_object* l_Nat_repr(lean_object*);
@@ -193,7 +193,6 @@ lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* l_Lean_registerParametricAttribute___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_toString___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__7___boxed(lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_numMinors___boxed(lean_object*);
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___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* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___spec__1___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getNumParams(lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
@@ -205,7 +204,6 @@ lean_object* l_Lean_getConstInfo___at_Lean_Meta_getParamNamesImp___spec__1(lean_
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___closed__1;
 lean_object* l_addParenHeuristic(lean_object*);
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__2(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___lambda__1___closed__2;
 extern lean_object* l_Lean_throwUnknownConstant___rarg___closed__5;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive_match__2___rarg(lean_object*, lean_object*);
@@ -218,7 +216,6 @@ lean_object* l_Array_binSearchAux___main___at_Lean_Meta_getMajorPos_x3f___spec__
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getParamsPos___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* l_Lean_Meta_RecursorUnivLevelPos_hasToString___closed__1;
 extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__2;
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getParamsPos___spec__2___closed__1;
 lean_object* l_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___closed__11;
 lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*);
@@ -228,9 +225,7 @@ uint8_t l_Array_isEmpty___rarg(lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive_match__3___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_syntaxToMajorPos_match__2___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forInAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getUnivLevelPos___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_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_syntaxToMajorPos___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___closed__7;
 lean_object* l_List_redLength___main___rarg(lean_object*);
@@ -244,16 +239,14 @@ lean_object* l_Lean_Meta_RecursorInfo_numIndices(lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux_match__3(lean_object*);
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___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* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___spec__2___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_syntaxToMajorPos___closed__2;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMotiveLevel_match__1(lean_object*);
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkRecursorInfo(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getParamsPos(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-size_t l_USize_mod(size_t, size_t);
 lean_object* l_Lean_Meta_mkBRecOnFor(lean_object*);
 lean_object* l_Lean_RecursorVal_getInduct(lean_object*);
 extern lean_object* l_Lean_Meta_State_inhabited___closed__1;
@@ -261,13 +254,11 @@ lean_object* l_Array_qsortAux___main___at_Lean_Meta_initFn____x40_Lean_Meta_Recu
 lean_object* l_Lean_ConstantInfo_lparams(lean_object*);
 lean_object* l_Lean_Meta_casesOnSuffix___closed__1;
 lean_object* l_Lean_registerParametricAttribute___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__2___lambda__1___boxed(lean_object*);
-lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim_match__2___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Expr_FindImpl_initCache;
 extern lean_object* l_Bool_HasRepr___closed__1;
 extern lean_object* l_Lean_Syntax_inhabited;
 lean_object* l_Array_back___at___private_Lean_Meta_ExprDefEq_0__Lean_Meta_processAssignmentFOApproxAux___spec__1(lean_object*);
-size_t lean_ptr_addr(lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___closed__1;
@@ -286,8 +277,10 @@ uint8_t l_Array_anyRangeMAux___main___at_Lean_Meta_initFn____x40_Lean_Meta_Recur
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosIfAuxRecursor_x3f_match__1(lean_object*);
 extern lean_object* l_Bool_HasRepr___closed__2;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMotiveLevel_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___spec__2___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_firstIndexPos___boxed(lean_object*);
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___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*, lean_object*);
 lean_object* l_Array_findIdxMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getParamsPos___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux_match__1(lean_object*);
 extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__3;
@@ -302,6 +295,7 @@ lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAnd
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoCore_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__4___closed__1;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMotiveLevel___closed__2;
+lean_object* l_Std_RBNode_fold___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_addAttribute___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_mkCasesOnFor(lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_motivePos(lean_object*);
@@ -309,7 +303,6 @@ lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isFVar(lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_syntaxToMajorPos_match__1(lean_object*);
 lean_object* l_List_toString___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__3(lean_object*);
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMotiveLevel(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Environment_getModuleIdxFor_x3f(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -330,7 +323,10 @@ lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lea
 lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getIndicesPos___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*);
 uint8_t l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotive___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2;
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___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* l_Array_findIdxMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getParamsPos___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoForKernelRec___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__4(uint8_t, lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_Meta_getMajorPos_x3f___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -349,12 +345,13 @@ lean_object* l_unsafeCast(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoAux_match__3___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
 lean_object* l_Lean_mkLevelParam(lean_object*);
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___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*);
 extern lean_object* l_Lean_getConstInfoInduct___rarg___lambda__1___closed__3;
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim_match__2(lean_object*);
-lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___boxed(lean_object*, lean_object*, 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_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getNumParams_match__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__2(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorUnivLevelPos_hasToString_match__1(lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_recOnSuffix___closed__1;
@@ -362,15 +359,13 @@ lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____clos
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___closed__3;
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__2(uint8_t, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive_match__1(lean_object*);
-lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_map___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_mkRecursorInfoForKernelRec___spec__4(lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isSort(lean_object*);
-lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getNumParams_match__1(lean_object*);
 lean_object* l_List_toStringAux___main___at_Lean_Meta_RecursorInfo_Lean_Meta_RecursorInfo___instance__1___spec__6___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_RecursorInfo_numIndices___boxed(lean_object*);
 lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____closed__2;
+lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_checkMotiveResultType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -3002,7 +2997,7 @@ x_26 = lean_nat_dec_lt(x_24, x_25);
 if (x_26 == 0)
 {
 lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
-x_27 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_25);
+x_27 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_25);
 x_28 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_28, 0, x_27);
 x_29 = l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getMajorPosDepElim___closed__6;
@@ -4540,471 +4535,7 @@ x_2 = lean_alloc_closure((void*)(l___private_Lean_Meta_RecursorInfo_0__Lean_Meta
 return x_2;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; size_t x_97; size_t x_98; lean_object* x_99; size_t x_100; uint8_t x_101; 
-x_97 = lean_ptr_addr(x_3);
-x_98 = x_2 == 0 ? 0 : x_97 % x_2;
-x_99 = lean_array_uget(x_4, x_98);
-x_100 = lean_ptr_addr(x_99);
-lean_dec(x_99);
-x_101 = x_100 == x_97;
-if (x_101 == 0)
-{
-lean_object* x_102; uint8_t x_103; 
-lean_inc(x_3);
-x_102 = lean_array_uset(x_4, x_98, x_3);
-x_103 = 0;
-x_5 = x_103;
-x_6 = x_102;
-goto block_96;
-}
-else
-{
-uint8_t x_104; 
-x_104 = 1;
-x_5 = x_104;
-x_6 = x_4;
-goto block_96;
-}
-block_96:
-{
-if (x_5 == 0)
-{
-uint8_t x_7; 
-x_7 = lean_expr_eqv(x_3, x_1);
-if (x_7 == 0)
-{
-switch (lean_obj_tag(x_3)) {
-case 5:
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-lean_dec(x_3);
-x_10 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_2, x_8, x_6);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-lean_dec(x_10);
-x_3 = x_9;
-x_4 = x_12;
-goto _start;
-}
-else
-{
-uint8_t x_14; 
-lean_dec(x_9);
-x_14 = !lean_is_exclusive(x_10);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_10, 0);
-lean_dec(x_15);
-x_16 = !lean_is_exclusive(x_11);
-if (x_16 == 0)
-{
-return x_10;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-x_17 = lean_ctor_get(x_11, 0);
-lean_inc(x_17);
-lean_dec(x_11);
-x_18 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_10, 0, x_18);
-return x_10;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_10, 1);
-lean_inc(x_19);
-lean_dec(x_10);
-x_20 = lean_ctor_get(x_11, 0);
-lean_inc(x_20);
-if (lean_is_exclusive(x_11)) {
- lean_ctor_release(x_11, 0);
- x_21 = x_11;
-} else {
- lean_dec_ref(x_11);
- x_21 = lean_box(0);
-}
-if (lean_is_scalar(x_21)) {
- x_22 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_22 = x_21;
-}
-lean_ctor_set(x_22, 0, x_20);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_22);
-lean_ctor_set(x_23, 1, x_19);
-return x_23;
-}
-}
-}
-case 6:
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = lean_ctor_get(x_3, 1);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_3, 2);
-lean_inc(x_25);
-lean_dec(x_3);
-x_26 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_2, x_24, x_6);
-x_27 = lean_ctor_get(x_26, 0);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; 
-x_28 = lean_ctor_get(x_26, 1);
-lean_inc(x_28);
-lean_dec(x_26);
-x_3 = x_25;
-x_4 = x_28;
-goto _start;
-}
-else
-{
-uint8_t x_30; 
-lean_dec(x_25);
-x_30 = !lean_is_exclusive(x_26);
-if (x_30 == 0)
-{
-lean_object* x_31; uint8_t x_32; 
-x_31 = lean_ctor_get(x_26, 0);
-lean_dec(x_31);
-x_32 = !lean_is_exclusive(x_27);
-if (x_32 == 0)
-{
-return x_26;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_27, 0);
-lean_inc(x_33);
-lean_dec(x_27);
-x_34 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_34, 0, x_33);
-lean_ctor_set(x_26, 0, x_34);
-return x_26;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_35 = lean_ctor_get(x_26, 1);
-lean_inc(x_35);
-lean_dec(x_26);
-x_36 = lean_ctor_get(x_27, 0);
-lean_inc(x_36);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- x_37 = x_27;
-} else {
- lean_dec_ref(x_27);
- x_37 = lean_box(0);
-}
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_38 = x_37;
-}
-lean_ctor_set(x_38, 0, x_36);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_35);
-return x_39;
-}
-}
-}
-case 7:
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_40 = lean_ctor_get(x_3, 1);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_3, 2);
-lean_inc(x_41);
-lean_dec(x_3);
-x_42 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_2, x_40, x_6);
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; 
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_3 = x_41;
-x_4 = x_44;
-goto _start;
-}
-else
-{
-uint8_t x_46; 
-lean_dec(x_41);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_42, 0);
-lean_dec(x_47);
-x_48 = !lean_is_exclusive(x_43);
-if (x_48 == 0)
-{
-return x_42;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; 
-x_49 = lean_ctor_get(x_43, 0);
-lean_inc(x_49);
-lean_dec(x_43);
-x_50 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_42, 0, x_50);
-return x_42;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_51 = lean_ctor_get(x_42, 1);
-lean_inc(x_51);
-lean_dec(x_42);
-x_52 = lean_ctor_get(x_43, 0);
-lean_inc(x_52);
-if (lean_is_exclusive(x_43)) {
- lean_ctor_release(x_43, 0);
- x_53 = x_43;
-} else {
- lean_dec_ref(x_43);
- x_53 = lean_box(0);
-}
-if (lean_is_scalar(x_53)) {
- x_54 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_54 = x_53;
-}
-lean_ctor_set(x_54, 0, x_52);
-x_55 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_51);
-return x_55;
-}
-}
-}
-case 8:
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_56 = lean_ctor_get(x_3, 1);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_3, 2);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_3, 3);
-lean_inc(x_58);
-lean_dec(x_3);
-x_59 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_2, x_56, x_6);
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_59, 1);
-lean_inc(x_61);
-lean_dec(x_59);
-x_62 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_2, x_57, x_61);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_62, 1);
-lean_inc(x_64);
-lean_dec(x_62);
-x_3 = x_58;
-x_4 = x_64;
-goto _start;
-}
-else
-{
-uint8_t x_66; 
-lean_dec(x_58);
-x_66 = !lean_is_exclusive(x_62);
-if (x_66 == 0)
-{
-lean_object* x_67; uint8_t x_68; 
-x_67 = lean_ctor_get(x_62, 0);
-lean_dec(x_67);
-x_68 = !lean_is_exclusive(x_63);
-if (x_68 == 0)
-{
-return x_62;
-}
-else
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_63, 0);
-lean_inc(x_69);
-lean_dec(x_63);
-x_70 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_62, 0, x_70);
-return x_62;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_71 = lean_ctor_get(x_62, 1);
-lean_inc(x_71);
-lean_dec(x_62);
-x_72 = lean_ctor_get(x_63, 0);
-lean_inc(x_72);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- x_73 = x_63;
-} else {
- lean_dec_ref(x_63);
- x_73 = lean_box(0);
-}
-if (lean_is_scalar(x_73)) {
- x_74 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_74 = x_73;
-}
-lean_ctor_set(x_74, 0, x_72);
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_71);
-return x_75;
-}
-}
-}
-else
-{
-uint8_t x_76; 
-lean_dec(x_58);
-lean_dec(x_57);
-x_76 = !lean_is_exclusive(x_59);
-if (x_76 == 0)
-{
-lean_object* x_77; uint8_t x_78; 
-x_77 = lean_ctor_get(x_59, 0);
-lean_dec(x_77);
-x_78 = !lean_is_exclusive(x_60);
-if (x_78 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_60, 0);
-lean_inc(x_79);
-lean_dec(x_60);
-x_80 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_59, 0, x_80);
-return x_59;
-}
-}
-else
-{
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_81 = lean_ctor_get(x_59, 1);
-lean_inc(x_81);
-lean_dec(x_59);
-x_82 = lean_ctor_get(x_60, 0);
-lean_inc(x_82);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- x_83 = x_60;
-} else {
- lean_dec_ref(x_60);
- x_83 = lean_box(0);
-}
-if (lean_is_scalar(x_83)) {
- x_84 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_84 = x_83;
-}
-lean_ctor_set(x_84, 0, x_82);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_81);
-return x_85;
-}
-}
-}
-case 10:
-{
-lean_object* x_86; 
-x_86 = lean_ctor_get(x_3, 1);
-lean_inc(x_86);
-lean_dec(x_3);
-x_3 = x_86;
-x_4 = x_6;
-goto _start;
-}
-case 11:
-{
-lean_object* x_88; 
-x_88 = lean_ctor_get(x_3, 2);
-lean_inc(x_88);
-lean_dec(x_3);
-x_3 = x_88;
-x_4 = x_6;
-goto _start;
-}
-default: 
-{
-lean_object* x_90; lean_object* x_91; 
-lean_dec(x_3);
-x_90 = lean_box(0);
-x_91 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_6);
-return x_91;
-}
-}
-}
-else
-{
-lean_object* x_92; lean_object* x_93; 
-x_92 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_92, 0, x_3);
-x_93 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_93, 0, x_92);
-lean_ctor_set(x_93, 1, x_6);
-return x_93;
-}
-}
-else
-{
-lean_object* x_94; lean_object* x_95; 
-lean_dec(x_3);
-x_94 = lean_box(0);
-x_95 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_95, 0, x_94);
-lean_ctor_set(x_95, 1, x_6);
-return x_95;
-}
-}
-}
-}
-lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
+lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
 _start:
 {
 uint8_t x_11; 
@@ -5017,6 +4548,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_1);
 x_12 = 0;
 x_13 = lean_box(x_12);
 x_14 = lean_alloc_ctor(0, 2, 0);
@@ -5039,114 +4571,123 @@ uint8_t x_17;
 x_17 = !lean_is_exclusive(x_16);
 if (x_17 == 0)
 {
-lean_object* x_18; lean_object* x_19; size_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+lean_object* x_18; lean_object* x_19; lean_object* x_20; size_t x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
 x_18 = lean_ctor_get(x_16, 0);
 x_19 = lean_ctor_get(x_16, 1);
-x_20 = 8192;
-x_21 = l_Lean_Expr_FindImpl_initCache;
-x_22 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_20, x_18, x_21);
-x_23 = lean_ctor_get(x_22, 0);
-lean_inc(x_23);
-lean_dec(x_22);
-if (lean_obj_tag(x_23) == 0)
+lean_inc(x_1);
+x_20 = lean_alloc_closure((void*)(l_Lean_Expr_occurs___lambda__1___boxed), 2, 1);
+lean_closure_set(x_20, 0, x_1);
+x_21 = 8192;
+x_22 = l_Lean_Expr_FindImpl_initCache;
+x_23 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_20, x_21, x_18, x_22);
+x_24 = lean_ctor_get(x_23, 0);
+lean_inc(x_24);
+lean_dec(x_23);
+if (lean_obj_tag(x_24) == 0)
 {
-lean_object* x_24; lean_object* x_25; 
+lean_object* x_25; lean_object* x_26; 
 lean_free_object(x_16);
-x_24 = lean_unsigned_to_nat(1u);
-x_25 = lean_nat_add(x_5, x_24);
+x_25 = lean_unsigned_to_nat(1u);
+x_26 = lean_nat_add(x_5, x_25);
 lean_dec(x_5);
-x_5 = x_25;
+x_5 = x_26;
 x_10 = x_19;
 goto _start;
 }
 else
 {
-uint8_t x_27; lean_object* x_28; 
-lean_dec(x_23);
+uint8_t x_28; lean_object* x_29; 
+lean_dec(x_24);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_27 = 1;
-x_28 = lean_box(x_27);
-lean_ctor_set(x_16, 0, x_28);
+lean_dec(x_1);
+x_28 = 1;
+x_29 = lean_box(x_28);
+lean_ctor_set(x_16, 0, x_29);
 return x_16;
 }
 }
 else
 {
-lean_object* x_29; lean_object* x_30; size_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
-x_29 = lean_ctor_get(x_16, 0);
-x_30 = lean_ctor_get(x_16, 1);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; size_t x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_30 = lean_ctor_get(x_16, 0);
+x_31 = lean_ctor_get(x_16, 1);
+lean_inc(x_31);
 lean_inc(x_30);
-lean_inc(x_29);
 lean_dec(x_16);
-x_31 = 8192;
-x_32 = l_Lean_Expr_FindImpl_initCache;
-x_33 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_31, x_29, x_32);
-x_34 = lean_ctor_get(x_33, 0);
-lean_inc(x_34);
-lean_dec(x_33);
-if (lean_obj_tag(x_34) == 0)
+lean_inc(x_1);
+x_32 = lean_alloc_closure((void*)(l_Lean_Expr_occurs___lambda__1___boxed), 2, 1);
+lean_closure_set(x_32, 0, x_1);
+x_33 = 8192;
+x_34 = l_Lean_Expr_FindImpl_initCache;
+x_35 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_32, x_33, x_30, x_34);
+x_36 = lean_ctor_get(x_35, 0);
+lean_inc(x_36);
+lean_dec(x_35);
+if (lean_obj_tag(x_36) == 0)
 {
-lean_object* x_35; lean_object* x_36; 
-x_35 = lean_unsigned_to_nat(1u);
-x_36 = lean_nat_add(x_5, x_35);
+lean_object* x_37; lean_object* x_38; 
+x_37 = lean_unsigned_to_nat(1u);
+x_38 = lean_nat_add(x_5, x_37);
 lean_dec(x_5);
-x_5 = x_36;
-x_10 = x_30;
+x_5 = x_38;
+x_10 = x_31;
 goto _start;
 }
 else
 {
-uint8_t x_38; lean_object* x_39; lean_object* x_40; 
-lean_dec(x_34);
+uint8_t x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_36);
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_38 = 1;
-x_39 = lean_box(x_38);
-x_40 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_40, 0, x_39);
-lean_ctor_set(x_40, 1, x_30);
-return x_40;
+lean_dec(x_1);
+x_40 = 1;
+x_41 = lean_box(x_40);
+x_42 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_42, 0, x_41);
+lean_ctor_set(x_42, 1, x_31);
+return x_42;
 }
 }
 }
 else
 {
-uint8_t x_41; 
+uint8_t x_43; 
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
-x_41 = !lean_is_exclusive(x_16);
-if (x_41 == 0)
+lean_dec(x_1);
+x_43 = !lean_is_exclusive(x_16);
+if (x_43 == 0)
 {
 return x_16;
 }
 else
 {
-lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_42 = lean_ctor_get(x_16, 0);
-x_43 = lean_ctor_get(x_16, 1);
-lean_inc(x_43);
-lean_inc(x_42);
+lean_object* x_44; lean_object* x_45; lean_object* x_46; 
+x_44 = lean_ctor_get(x_16, 0);
+x_45 = lean_ctor_get(x_16, 1);
+lean_inc(x_45);
+lean_inc(x_44);
 lean_dec(x_16);
-x_44 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_44, 0, x_42);
-lean_ctor_set(x_44, 1, x_43);
-return x_44;
+x_46 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_46, 0, x_44);
+lean_ctor_set(x_46, 1, x_45);
+return x_46;
 }
 }
 }
 }
 }
-lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___lambda__1(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
 lean_object* x_8; lean_object* x_9; lean_object* x_10; 
@@ -5160,7 +4701,7 @@ lean_ctor_set(x_10, 1, x_7);
 return x_10;
 }
 }
-lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) {
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) {
 _start:
 {
 if (lean_obj_tag(x_5) == 5)
@@ -5198,7 +4739,7 @@ lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_9);
 lean_inc(x_8);
-x_24 = l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(x_1, x_4, x_4, x_22, x_23, x_8, x_9, x_10, x_11, x_12);
+x_24 = l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_4, x_4, x_22, x_23, x_8, x_9, x_10, x_11, x_12);
 lean_dec(x_22);
 if (lean_obj_tag(x_24) == 0)
 {
@@ -5210,7 +4751,7 @@ lean_inc(x_26);
 lean_dec(x_24);
 x_27 = lean_unbox(x_25);
 lean_dec(x_25);
-x_28 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(x_21, x_27, x_8, x_9, x_10, x_11, x_26);
+x_28 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___lambda__1(x_21, x_27, x_8, x_9, x_10, x_11, x_26);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -5248,7 +4789,8 @@ return x_32;
 else
 {
 lean_object* x_33; 
-x_33 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(x_21, x_2, x_8, x_9, x_10, x_11, x_12);
+lean_dec(x_1);
+x_33 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___lambda__1(x_21, x_2, x_8, x_9, x_10, x_11, x_12);
 lean_dec(x_11);
 lean_dec(x_10);
 lean_dec(x_9);
@@ -5258,7 +4800,7 @@ return x_33;
 }
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__1(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(lean_object* x_1, uint8_t x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
 _start:
 {
 lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
@@ -5270,11 +4812,11 @@ x_14 = lean_mk_array(x_12, x_13);
 x_15 = lean_unsigned_to_nat(1u);
 x_16 = lean_nat_sub(x_12, x_15);
 lean_dec(x_12);
-x_17 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3(x_1, x_2, x_3, x_4, x_5, x_14, x_16, x_6, x_7, x_8, x_9, x_10);
+x_17 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(x_1, x_2, x_3, x_4, x_5, x_14, x_16, x_6, x_7, x_8, x_9, x_10);
 return x_17;
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, uint8_t x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
 _start:
 {
 lean_object* x_12; lean_object* x_13; lean_object* x_14; 
@@ -5294,7 +4836,7 @@ x_16 = lean_ctor_get(x_14, 1);
 lean_inc(x_16);
 lean_dec(x_14);
 x_17 = lean_box(x_4);
-x_18 = lean_alloc_closure((void*)(l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__1___boxed), 10, 3);
+x_18 = lean_alloc_closure((void*)(l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1___boxed), 10, 3);
 lean_closure_set(x_18, 0, x_3);
 lean_closure_set(x_18, 1, x_17);
 lean_closure_set(x_18, 2, x_5);
@@ -5397,7 +4939,7 @@ return x_40;
 }
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) {
 _start:
 {
 lean_object* x_14; uint8_t x_15; 
@@ -5408,7 +4950,7 @@ if (x_15 == 0)
 {
 lean_object* x_16; lean_object* x_17; 
 x_16 = lean_box(0);
-x_17 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__2(x_1, x_2, x_3, x_6, x_7, x_16, x_9, x_10, x_11, x_12, x_13);
+x_17 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__2(x_1, x_2, x_3, x_6, x_7, x_16, x_9, x_10, x_11, x_12, x_13);
 return x_17;
 }
 else
@@ -5419,7 +4961,7 @@ if (x_18 == 0)
 {
 lean_object* x_19; lean_object* x_20; 
 x_19 = lean_box(0);
-x_20 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__2(x_1, x_2, x_3, x_6, x_7, x_19, x_9, x_10, x_11, x_12, x_13);
+x_20 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__2(x_1, x_2, x_3, x_6, x_7, x_19, x_9, x_10, x_11, x_12, x_13);
 return x_20;
 }
 else
@@ -5444,7 +4986,7 @@ return x_24;
 }
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) {
 _start:
 {
 lean_object* x_15; uint8_t x_16; 
@@ -5482,7 +5024,7 @@ lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_5);
-x_28 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__3(x_1, x_8, x_5, x_4, x_3, x_27, x_23, x_26, x_10, x_11, x_12, x_13, x_14);
+x_28 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__3(x_1, x_8, x_5, x_4, x_3, x_27, x_23, x_26, x_10, x_11, x_12, x_13, x_14);
 if (lean_obj_tag(x_28) == 0)
 {
 lean_object* x_29; 
@@ -5607,7 +5149,7 @@ lean_inc(x_12);
 lean_inc(x_11);
 lean_inc(x_10);
 lean_inc(x_5);
-x_54 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__3(x_1, x_8, x_5, x_4, x_3, x_53, x_49, x_52, x_10, x_11, x_12, x_13, x_14);
+x_54 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__3(x_1, x_8, x_5, x_4, x_3, x_53, x_49, x_52, x_10, x_11, x_12, x_13, x_14);
 if (lean_obj_tag(x_54) == 0)
 {
 lean_object* x_55; 
@@ -5771,7 +5313,7 @@ lean_ctor_set(x_14, 0, x_12);
 lean_ctor_set(x_14, 1, x_11);
 lean_ctor_set(x_14, 2, x_13);
 x_15 = l___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___closed__1;
-x_16 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4(x_1, x_2, x_3, x_4, x_5, x_14, x_11, x_12, x_15, x_6, x_7, x_8, x_9, x_10);
+x_16 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3(x_1, x_2, x_3, x_4, x_5, x_14, x_11, x_12, x_15, x_6, x_7, x_8, x_9, x_10);
 lean_dec(x_14);
 if (lean_obj_tag(x_16) == 0)
 {
@@ -5842,36 +5384,24 @@ return x_33;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-size_t x_5; lean_object* x_6; 
-x_5 = lean_unbox_usize(x_2);
-lean_dec(x_2);
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_5, x_3, x_4);
-lean_dec(x_1);
-return x_6;
-}
-}
-lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
+lean_object* l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
 _start:
 {
 lean_object* x_11; 
-x_11 = l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
+x_11 = l_Array_anyRangeMAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-lean_dec(x_1);
 return x_11;
 }
 }
-lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
 uint8_t x_8; lean_object* x_9; 
 x_8 = lean_unbox(x_2);
 lean_dec(x_2);
-x_9 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(x_1, x_8, x_3, x_4, x_5, x_6, x_7);
+x_9 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___lambda__1(x_1, x_8, x_3, x_4, x_5, x_6, x_7);
 lean_dec(x_6);
 lean_dec(x_5);
 lean_dec(x_4);
@@ -5879,50 +5409,48 @@ lean_dec(x_3);
 return x_9;
 }
 }
-lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) {
+lean_object* l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) {
 _start:
 {
 uint8_t x_13; lean_object* x_14; 
 x_13 = lean_unbox(x_2);
 lean_dec(x_2);
-x_14 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3(x_1, x_13, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12);
+x_14 = l_Lean_Expr_withAppAux___main___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__2(x_1, x_13, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12);
 lean_dec(x_4);
-lean_dec(x_1);
 return x_14;
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) {
 _start:
 {
 uint8_t x_11; lean_object* x_12; 
 x_11 = lean_unbox(x_2);
 lean_dec(x_2);
-x_12 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__1(x_1, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
+x_12 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__1(x_1, x_11, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10);
 lean_dec(x_4);
-lean_dec(x_1);
 return x_12;
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) {
 _start:
 {
 uint8_t x_12; lean_object* x_13; 
 x_12 = lean_unbox(x_4);
 lean_dec(x_4);
-x_13 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__2(x_1, x_2, x_3, x_12, x_5, x_6, x_7, x_8, x_9, x_10, x_11);
+x_13 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__2(x_1, x_2, x_3, x_12, x_5, x_6, x_7, x_8, x_9, x_10, x_11);
 lean_dec(x_6);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_13;
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) {
 _start:
 {
 uint8_t x_14; lean_object* x_15; 
 x_14 = lean_unbox(x_6);
 lean_dec(x_6);
-x_15 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___lambda__3(x_1, x_2, x_3, x_4, x_5, x_14, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
+x_15 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___lambda__3(x_1, x_2, x_3, x_4, x_5, x_14, x_7, x_8, x_9, x_10, x_11, x_12, x_13);
 lean_dec(x_8);
 lean_dec(x_5);
 lean_dec(x_4);
@@ -5931,11 +5459,11 @@ lean_dec(x_1);
 return x_15;
 }
 }
-lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) {
+lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) {
 _start:
 {
 lean_object* x_15; 
-x_15 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__4(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14);
+x_15 = l_Std_Range_forIn_loop___at___private_Lean_Meta_RecursorInfo_0__Lean_Meta_getProduceMotiveAndRecursive___spec__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14);
 lean_dec(x_6);
 lean_dec(x_4);
 lean_dec(x_3);
@@ -9325,7 +8853,7 @@ return x_11;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -9339,7 +8867,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -9883,7 +9411,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -10174,11 +9702,11 @@ lean_dec(x_1);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_Meta_initFn____x40_Lean_Meta_RecursorInfo___hyg_2078____spec__3(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -10347,7 +9875,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at_Lean_sanitizeName___spec__1(x_6, x_3);
+x_7 = l_Std_RBNode_find___at_Lean_sanitizeName___spec__1(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
diff --git a/stage0/stdlib/Lean/Meta/SynthInstance.c b/stage0/stdlib/Lean/Meta/SynthInstance.c
index f8e4d34266..b7aebdb74b 100644
--- a/stage0/stdlib/Lean/Meta/SynthInstance.c
+++ b/stage0/stdlib/Lean/Meta/SynthInstance.c
@@ -18,7 +18,6 @@ lean_object* l_List_reverse___rarg(lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Meta_SynthInstance_getInstances___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_AssocList_contains___at_Lean_Meta_SynthInstance_newSubgoal___spec__5___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isExprMVarAssigned___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_synthPendingImp___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* lean_expr_update_forall(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_MkTableKey_normExpr_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isExprDefEq___at_Lean_Meta_SynthInstance_tryAnswer___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -126,6 +125,7 @@ lean_object* l_Lean_Meta_SynthInstance_getEntry___closed__3;
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Std_PersistentHashMap_getCollisionNodeSize___rarg(lean_object*);
 lean_object* l_Lean_addTrace___at_Lean_Meta_SynthInstance_newSubgoal___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_Lean_Meta_SynthInstance_Answer_inhabited;
 lean_object* l_Lean_Meta_SynthInstance_tryResolveCore___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MessageData_ofList(lean_object*);
@@ -14232,7 +14232,7 @@ else
 {
 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_inc(x_11);
-x_69 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_11);
+x_69 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_11);
 x_70 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_70, 0, x_69);
 x_71 = l_Lean_Meta_SynthInstance_synth___closed__4;
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Apply.c b/stage0/stdlib/Lean/Meta/Tactic/Apply.c
index be828fd959..f9f0d33385 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Apply.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Apply.c
@@ -19,6 +19,7 @@ lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_stringToMessageData(lean_object*);
 lean_object* l_Lean_Meta_apply_match__2___rarg(lean_object*, lean_object*);
 lean_object* l_List_elem___main___at_Lean_Meta_apply___spec__3___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_getExpectedNumArgsAux___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_isExprDefEq___at_Lean_Meta_isExprDefEqGuarded___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterAux___main___at_Lean_Meta_apply___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -51,6 +52,7 @@ lean_object* l_Lean_Meta_postprocessAppMVars(lean_object*, lean_object*, lean_ob
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_synthAppInstances___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_apply(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___lambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_apply___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_reorderNonDependentFirst___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_appendParentTag___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -58,13 +60,15 @@ lean_object* l_Lean_Meta_apply___lambda__2___boxed(lean_object*, lean_object*, l
 lean_object* lean_array_fget(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Meta_getMVarType(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_forallMetaTelescopeReducingAux(lean_object*, uint8_t, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_filterMAux___main___at_Lean_Meta_apply___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Nat_forMAux___main___at_Lean_Meta_synthAppInstances___spec__1___closed__3;
+lean_object* l_Lean_FindMVar_visit(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_throwApplyError___rarg___closed__6;
 uint8_t l_List_elem___main___at_Lean_Meta_apply___spec__3(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_getExpectedNumArgs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -93,7 +97,6 @@ lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_reorderNonDependent
 uint8_t lean_expr_eqv(lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isMVar(lean_object*);
 lean_object* l_Lean_Meta_synthAppInstances(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Expr_hasMVar(lean_object*);
 uint8_t l_Lean_Name_isAnonymous(lean_object*);
 extern lean_object* l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_getExpectedNumArgsAux___closed__1;
@@ -110,7 +113,6 @@ lean_object* l_Lean_Meta_instantiateMVars___at_Lean_Meta_instantiateLocalDeclMVa
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_reorderNonDependentFirst_match__1(lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_reorderNonDependentFirst_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Nat_forMAux___main___at_Lean_Meta_synthAppInstances___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_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_mkAppN___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_forMAux___main___at_Lean_Meta_appendParentTag___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_throwApplyError___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1196,325 +1198,149 @@ lean_dec(x_3);
 return x_10;
 }
 }
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+uint8_t l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
+lean_object* x_3; uint8_t x_4; 
+x_3 = l_Lean_Expr_mvarId_x21(x_1);
+x_4 = lean_name_eq(x_2, x_3);
+lean_dec(x_3);
+return x_4;
+}
+}
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+lean_inc(x_1);
+x_4 = lean_alloc_closure((void*)(l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___lambda__1___boxed), 2, 1);
+lean_closure_set(x_4, 0, x_1);
 switch (lean_obj_tag(x_2)) {
 case 2:
 {
+lean_dec(x_4);
 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, 0);
-x_5 = l_Lean_Expr_mvarId_x21(x_1);
-x_6 = lean_name_eq(x_4, x_5);
-lean_dec(x_5);
-if (x_6 == 0)
+lean_object* x_5; lean_object* x_6; uint8_t x_7; 
+x_5 = lean_ctor_get(x_2, 0);
+lean_inc(x_5);
+lean_dec(x_2);
+x_6 = l_Lean_Expr_mvarId_x21(x_1);
+lean_dec(x_1);
+x_7 = lean_name_eq(x_5, x_6);
+lean_dec(x_6);
+if (x_7 == 0)
 {
+lean_dec(x_5);
 return x_3;
 }
 else
 {
-lean_object* x_7; 
-lean_inc(x_4);
-x_7 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_7, 0, x_4);
-return x_7;
+lean_object* x_8; 
+x_8 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_8, 0, x_5);
+return x_8;
 }
 }
 else
 {
+lean_dec(x_2);
+lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
 case 5:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; 
-x_8 = lean_ctor_get(x_2, 0);
-x_9 = lean_ctor_get(x_2, 1);
-x_10 = l_Lean_Expr_hasMVar(x_8);
-if (x_10 == 0)
-{
-uint8_t x_11; 
-x_11 = l_Lean_Expr_hasMVar(x_9);
-if (x_11 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_9;
-goto _start;
-}
-}
-else
-{
-lean_object* x_13; 
-x_13 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_8, x_3);
-if (lean_obj_tag(x_13) == 0)
-{
-uint8_t x_14; 
-x_14 = l_Lean_Expr_hasMVar(x_9);
-if (x_14 == 0)
-{
-return x_13;
-}
-else
-{
-x_2 = x_9;
-x_3 = x_13;
-goto _start;
-}
-}
-else
-{
-return x_13;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_1);
+x_9 = lean_ctor_get(x_2, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_2, 1);
+lean_inc(x_10);
+lean_dec(x_2);
+lean_inc(x_4);
+x_11 = l_Lean_FindMVar_visit(x_4, x_9, x_3);
+x_12 = l_Lean_FindMVar_visit(x_4, x_10, x_11);
+lean_dec(x_11);
+return x_12;
 }
 case 6:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_16; lean_object* x_17; uint8_t x_18; 
-x_16 = lean_ctor_get(x_2, 1);
-x_17 = lean_ctor_get(x_2, 2);
-x_18 = l_Lean_Expr_hasMVar(x_16);
-if (x_18 == 0)
-{
-uint8_t x_19; 
-x_19 = l_Lean_Expr_hasMVar(x_17);
-if (x_19 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_17;
-goto _start;
-}
-}
-else
-{
-lean_object* x_21; 
-x_21 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_16, x_3);
-if (lean_obj_tag(x_21) == 0)
-{
-uint8_t x_22; 
-x_22 = l_Lean_Expr_hasMVar(x_17);
-if (x_22 == 0)
-{
-return x_21;
-}
-else
-{
-x_2 = x_17;
-x_3 = x_21;
-goto _start;
-}
-}
-else
-{
-return x_21;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_1);
+x_13 = lean_ctor_get(x_2, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get(x_2, 2);
+lean_inc(x_14);
+lean_dec(x_2);
+lean_inc(x_4);
+x_15 = l_Lean_FindMVar_visit(x_4, x_13, x_3);
+x_16 = l_Lean_FindMVar_visit(x_4, x_14, x_15);
+lean_dec(x_15);
+return x_16;
 }
 case 7:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_2, 1);
-x_25 = lean_ctor_get(x_2, 2);
-x_26 = l_Lean_Expr_hasMVar(x_24);
-if (x_26 == 0)
-{
-uint8_t x_27; 
-x_27 = l_Lean_Expr_hasMVar(x_25);
-if (x_27 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_25;
-goto _start;
-}
-}
-else
-{
-lean_object* x_29; 
-x_29 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_24, x_3);
-if (lean_obj_tag(x_29) == 0)
-{
-uint8_t x_30; 
-x_30 = l_Lean_Expr_hasMVar(x_25);
-if (x_30 == 0)
-{
-return x_29;
-}
-else
-{
-x_2 = x_25;
-x_3 = x_29;
-goto _start;
-}
-}
-else
-{
-return x_29;
-}
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; 
+lean_dec(x_1);
+x_17 = lean_ctor_get(x_2, 1);
+lean_inc(x_17);
+x_18 = lean_ctor_get(x_2, 2);
+lean_inc(x_18);
+lean_dec(x_2);
+lean_inc(x_4);
+x_19 = l_Lean_FindMVar_visit(x_4, x_17, x_3);
+x_20 = l_Lean_FindMVar_visit(x_4, x_18, x_19);
+lean_dec(x_19);
+return x_20;
 }
 case 8:
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_2, 1);
-x_33 = lean_ctor_get(x_2, 2);
-x_34 = lean_ctor_get(x_2, 3);
-if (lean_obj_tag(x_3) == 0)
-{
-uint8_t x_43; 
-x_43 = l_Lean_Expr_hasMVar(x_32);
-if (x_43 == 0)
-{
-x_35 = x_3;
-goto block_42;
-}
-else
-{
-lean_object* x_44; 
-x_44 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_32, x_3);
-if (lean_obj_tag(x_44) == 0)
-{
-x_35 = x_44;
-goto block_42;
-}
-else
-{
-return x_44;
-}
-}
-}
-else
-{
-return x_3;
-}
-block_42:
-{
-uint8_t x_36; 
-x_36 = l_Lean_Expr_hasMVar(x_33);
-if (x_36 == 0)
-{
-if (lean_obj_tag(x_35) == 0)
-{
-uint8_t x_37; 
-x_37 = l_Lean_Expr_hasMVar(x_34);
-if (x_37 == 0)
-{
-return x_35;
-}
-else
-{
-x_2 = x_34;
-x_3 = x_35;
-goto _start;
-}
-}
-else
-{
-return x_35;
-}
-}
-else
-{
-lean_object* x_39; 
-x_39 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_33, x_35);
-if (lean_obj_tag(x_39) == 0)
-{
-uint8_t x_40; 
-x_40 = l_Lean_Expr_hasMVar(x_34);
-if (x_40 == 0)
-{
-return x_39;
-}
-else
-{
-x_2 = x_34;
-x_3 = x_39;
-goto _start;
-}
-}
-else
-{
-return x_39;
-}
-}
-}
+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_dec(x_1);
+x_21 = lean_ctor_get(x_2, 1);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_2, 2);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_2, 3);
+lean_inc(x_23);
+lean_dec(x_2);
+lean_inc(x_4);
+x_24 = l_Lean_FindMVar_visit(x_4, x_21, x_3);
+lean_inc(x_4);
+x_25 = l_Lean_FindMVar_visit(x_4, x_22, x_24);
+lean_dec(x_24);
+x_26 = l_Lean_FindMVar_visit(x_4, x_23, x_25);
+lean_dec(x_25);
+return x_26;
 }
 case 10:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_45; uint8_t x_46; 
-x_45 = lean_ctor_get(x_2, 1);
-x_46 = l_Lean_Expr_hasMVar(x_45);
-if (x_46 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_45;
-goto _start;
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_27; lean_object* x_28; 
+lean_dec(x_1);
+x_27 = lean_ctor_get(x_2, 1);
+lean_inc(x_27);
+lean_dec(x_2);
+x_28 = l_Lean_FindMVar_visit(x_4, x_27, x_3);
+return x_28;
 }
 case 11:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_48; uint8_t x_49; 
-x_48 = lean_ctor_get(x_2, 2);
-x_49 = l_Lean_Expr_hasMVar(x_48);
-if (x_49 == 0)
-{
-return x_3;
-}
-else
-{
-x_2 = x_48;
-goto _start;
-}
-}
-else
-{
-return x_3;
-}
+lean_object* x_29; lean_object* x_30; 
+lean_dec(x_1);
+x_29 = lean_ctor_get(x_2, 2);
+lean_inc(x_29);
+lean_dec(x_2);
+x_30 = l_Lean_FindMVar_visit(x_4, x_29, x_3);
+return x_30;
 }
 default: 
 {
+lean_dec(x_4);
+lean_dec(x_2);
+lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
@@ -1533,6 +1359,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_1);
 x_12 = 0;
 x_13 = lean_box(x_12);
 x_14 = lean_alloc_ctor(0, 2, 0);
@@ -1563,8 +1390,8 @@ lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22;
 x_19 = lean_ctor_get(x_17, 0);
 x_20 = lean_ctor_get(x_17, 1);
 x_21 = lean_box(0);
-x_22 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_19, x_21);
-lean_dec(x_19);
+lean_inc(x_1);
+x_22 = l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_19, x_21);
 if (lean_obj_tag(x_22) == 0)
 {
 lean_object* x_23; lean_object* x_24; 
@@ -1585,6 +1412,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_1);
 x_26 = 1;
 x_27 = lean_box(x_26);
 lean_ctor_set(x_17, 0, x_27);
@@ -1600,8 +1428,8 @@ lean_inc(x_29);
 lean_inc(x_28);
 lean_dec(x_17);
 x_30 = lean_box(0);
-x_31 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_28, x_30);
-lean_dec(x_28);
+lean_inc(x_1);
+x_31 = l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_28, x_30);
 if (lean_obj_tag(x_31) == 0)
 {
 lean_object* x_32; lean_object* x_33; 
@@ -1621,6 +1449,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_1);
 x_35 = 1;
 x_36 = lean_box(x_35);
 x_37 = lean_alloc_ctor(0, 2, 0);
@@ -1638,6 +1467,7 @@ lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_5);
+lean_dec(x_1);
 x_38 = !lean_is_exclusive(x_17);
 if (x_38 == 0)
 {
@@ -1682,13 +1512,23 @@ lean_dec(x_8);
 return x_10;
 }
 }
-lean_object* l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___lambda__1(x_1, x_2);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(x_3);
+return x_4;
+}
+}
+lean_object* l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_FindMVar_main___main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_2, x_3);
-lean_dec(x_2);
-lean_dec(x_1);
+x_4 = l_Lean_FindMVar_main___at___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers___spec__1(x_1, x_2, x_3);
+lean_dec(x_3);
 return x_4;
 }
 }
@@ -1700,7 +1540,6 @@ x_11 = l_Array_anyRangeMAux___main___at___private_Lean_Meta_Tactic_Apply_0__Lean
 lean_dec(x_4);
 lean_dec(x_3);
 lean_dec(x_2);
-lean_dec(x_1);
 return x_11;
 }
 }
@@ -1710,7 +1549,6 @@ _start:
 lean_object* x_8; 
 x_8 = l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
 lean_dec(x_2);
-lean_dec(x_1);
 return x_8;
 }
 }
@@ -1795,7 +1633,6 @@ lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 x_20 = l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers(x_13, x_1, x_5, x_6, x_7, x_8, x_9);
-lean_dec(x_13);
 if (lean_obj_tag(x_20) == 0)
 {
 lean_object* x_21; uint8_t x_22; 
@@ -1874,7 +1711,6 @@ lean_inc(x_7);
 lean_inc(x_6);
 lean_inc(x_5);
 x_36 = l___private_Lean_Meta_Tactic_Apply_0__Lean_Meta_dependsOnOthers(x_13, x_1, x_5, x_6, x_7, x_8, x_9);
-lean_dec(x_13);
 if (lean_obj_tag(x_36) == 0)
 {
 lean_object* x_37; uint8_t x_38; 
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Cases.c b/stage0/stdlib/Lean/Meta/Tactic/Cases.c
index ca3c7610bd..a4ba92b19e 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Cases.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Cases.c
@@ -14,7 +14,6 @@
 extern "C" {
 #endif
 lean_object* l___private_Lean_Meta_Tactic_Cases_0__Lean_Meta_Cases_unifyEqsAux_match__7___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_Meta_assert(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at___private_Lean_Meta_Tactic_Cases_0__Lean_Meta_Cases_hasIndepIndices___spec__44(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Cases_0__Lean_Meta_Cases_unifyEqs___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -89,6 +88,7 @@ lean_object* l_Std_PersistentArray_anyMAux___at___private_Lean_Meta_Tactic_Cases
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 extern lean_object* l___private_Lean_Meta_AppBuilder_0__Lean_Meta_mkEqReflImp___closed__2;
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_Array_umapMAux___main___at___private_Lean_Meta_Tactic_Cases_0__Lean_Meta_Cases_unifyEqsAux___spec__18(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getAppFn___main(lean_object*);
 extern lean_object* l_Lean_Name_inhabited;
@@ -16602,7 +16602,7 @@ else
 {
 lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
 x_35 = lean_nat_add(x_11, x_10);
-x_36 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_35);
+x_36 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_35);
 x_37 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_37, 0, x_36);
 x_38 = l___private_Lean_Meta_Tactic_Cases_0__Lean_Meta_Cases_unifyEqsAux___closed__3;
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Induction.c b/stage0/stdlib/Lean/Meta/Tactic/Induction.c
index 2cb73ee3c1..8d39d0db78 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Induction.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Induction.c
@@ -14,9 +14,9 @@
 extern "C" {
 #endif
 lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_induction___spec__12___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*, lean_object*, lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_Meta_induction___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_array_set(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Lean_Level_normalize___main(lean_object*);
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
@@ -64,6 +64,7 @@ lean_object* l_Nat_forMAux___main___at_Lean_Meta_induction___spec__6___lambda__1
 lean_object* lean_array_push(lean_object*, lean_object*);
 lean_object* lean_array_get_size(lean_object*);
 lean_object* l_Nat_forMAux___main___at_Lean_Meta_induction___spec__6___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* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_induction___spec__11___closed__2;
 extern lean_object* l_Lean_Name_inhabited;
 extern lean_object* l_Lean_Level_Inhabited;
@@ -207,7 +208,6 @@ lean_object* l_Lean_Expr_withAppAux___main___at_Lean_Meta_induction___spec__12__
 lean_object* l_List_foldlM___main___at_Lean_Meta_induction___spec__10___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Induction_0__Lean_Meta_finalize_loop(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_Tactic_Induction_0__Lean_Meta_finalize_loop___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_induction_match__3___rarg(lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isFVar(lean_object*);
@@ -1743,7 +1743,7 @@ x_1 = l___private_Lean_Meta_Tactic_Induction_0__Lean_Meta_finalize_loop___lambda
 x_2 = l___private_Lean_Meta_Tactic_Induction_0__Lean_Meta_finalize_loop___lambda__3___closed__2;
 x_3 = lean_unsigned_to_nat(113u);
 x_4 = lean_unsigned_to_nat(13u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -4615,7 +4615,7 @@ lean_ctor_set(x_31, 0, x_29);
 lean_ctor_set(x_31, 1, x_30);
 x_32 = lean_unsigned_to_nat(1u);
 x_33 = lean_nat_add(x_4, x_32);
-x_34 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_33);
+x_34 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_33);
 x_35 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_35, 0, x_34);
 x_36 = lean_alloc_ctor(10, 2, 0);
@@ -4672,7 +4672,7 @@ lean_ctor_set(x_52, 0, x_50);
 lean_ctor_set(x_52, 1, x_51);
 x_53 = lean_unsigned_to_nat(1u);
 x_54 = lean_nat_add(x_4, x_53);
-x_55 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_54);
+x_55 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_54);
 x_56 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_56, 0, x_55);
 x_57 = lean_alloc_ctor(10, 2, 0);
diff --git a/stage0/stdlib/Lean/Meta/Tactic/Subst.c b/stage0/stdlib/Lean/Meta/Tactic/Subst.c
index c492686fc8..9c6b71e358 100644
--- a/stage0/stdlib/Lean/Meta/Tactic/Subst.c
+++ b/stage0/stdlib/Lean/Meta/Tactic/Subst.c
@@ -16,6 +16,7 @@ extern "C" {
 lean_object* l_Array_findSomeMAux___main___at_Lean_Meta_subst___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_substCore___lambda__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_Meta_withLocalDecl___at_Lean_Meta_substCore___spec__4(lean_object*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Lean_Meta_substCore___lambda__3___boxed(lean_object**);
 lean_object* l_Lean_Expr_mvarId_x21(lean_object*);
 lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*);
@@ -140,7 +141,6 @@ lean_object* l_Lean_Meta_substCore___lambda__13___closed__24;
 lean_object* l_Lean_Meta_substCore_match__6___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_substCore___lambda__9___boxed(lean_object**);
 lean_object* l_Lean_Meta_substCore___lambda__13___closed__15;
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Meta_substCore___lambda__13___closed__19;
 lean_object* l_Lean_Meta_substCore_match__1(lean_object*);
 uint8_t l_Lean_Expr_isFVar(lean_object*);
@@ -1915,7 +1915,7 @@ x_1 = l_Lean_Meta_substCore___lambda__11___closed__3;
 x_2 = l_Lean_Meta_substCore___lambda__11___closed__4;
 x_3 = lean_unsigned_to_nat(49u);
 x_4 = lean_unsigned_to_nat(18u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Meta/WHNF.c b/stage0/stdlib/Lean/Meta/WHNF.c
index f6161074d2..bd47d04541 100644
--- a/stage0/stdlib/Lean/Meta/WHNF.c
+++ b/stage0/stdlib/Lean/Meta/WHNF.c
@@ -14,12 +14,12 @@
 extern "C" {
 #endif
 lean_object* lean_string_data(lean_object*);
-lean_object* l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(lean_object*);
 lean_object* l_Lean_Meta_reduceNative_x3f___closed__1;
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_getStuckMVarImp_x3f_match__3(lean_object*);
 lean_object* l_Lean_throwError___at_Lean_Meta_initFn____x40_Lean_Meta_Basic___hyg_916____spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_isIdRhsApp___boxed(lean_object*);
 uint8_t l_Array_anyRangeMAux___main___at___private_Lean_Meta_WHNF_0__Lean_Meta_toCtorWhenK___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_Name_getString_x21___closed__3;
 lean_object* l_Lean_Meta_reduceNative_x3f___closed__2;
 lean_object* l_Lean_Meta_whnfImp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_isIdRhsApp___closed__1;
@@ -98,6 +98,7 @@ lean_object* l_Lean_Meta_getConfig___at___private_Lean_Meta_WHNF_0__Lean_Meta_wh
 lean_object* l_List_find_x3f___main___rarg(lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_isRecStuck_x3f___at___private_Lean_Meta_WHNF_0__Lean_Meta_getStuckMVarImp_x3f___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases_match__1(lean_object*);
+lean_object* l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfCoreImp_match__3(lean_object*);
 lean_object* l_Lean_Expr_getAppFn___main(lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_reduceQuotRec(lean_object*);
@@ -303,7 +304,6 @@ lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_cached_x3f_match__1(lean_ob
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfCoreImp_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___at___private_Lean_Meta_WHNF_0__Lean_Meta_whnfCoreImp___spec__2___closed__4;
 lean_object* l_Lean_Meta_whnfHeadPredImp_match__1(lean_object*);
-extern lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 lean_object* l_Lean_Meta_reduceBinNatOp(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Meta_toCtorIfLit___closed__11;
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
@@ -5401,7 +5401,7 @@ x_1 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___closed__1;
 x_2 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___closed__2;
 x_3 = lean_unsigned_to_nat(205u);
 x_4 = lean_unsigned_to_nat(33u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -5414,7 +5414,7 @@ x_1 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___closed__1;
 x_2 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___closed__2;
 x_3 = lean_unsigned_to_nat(227u);
 x_4 = lean_unsigned_to_nat(33u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -6309,7 +6309,7 @@ x_1 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___closed__1;
 x_2 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___at___private_Lean_Meta_WHNF_0__Lean_Meta_whnfCoreImp___spec__2___closed__1;
 x_3 = lean_unsigned_to_nat(296u);
 x_4 = lean_unsigned_to_nat(9u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -14981,7 +14981,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; 
 x_1 = lean_unsigned_to_nat(0u);
-x_2 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_1);
+x_2 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_1);
 return x_2;
 }
 }
@@ -15537,7 +15537,7 @@ else
 lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; uint8_t x_112; 
 lean_dec(x_95);
 lean_inc(x_96);
-x_104 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_96);
+x_104 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_96);
 x_105 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_105, 0, x_104);
 x_106 = l_Lean_Meta_reduceBinNatOp___closed__9;
@@ -16113,7 +16113,7 @@ else
 lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; 
 lean_dec(x_223);
 lean_inc(x_224);
-x_232 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_224);
+x_232 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_224);
 x_233 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_233, 0, x_232);
 x_234 = l_Lean_Meta_reduceBinNatOp___closed__9;
@@ -16533,7 +16533,7 @@ else
 lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; uint8_t x_328; 
 lean_dec(x_299);
 lean_inc(x_292);
-x_317 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_292);
+x_317 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_292);
 x_318 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_318, 0, x_317);
 x_319 = l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
@@ -16784,7 +16784,7 @@ else
 lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; uint8_t x_393; 
 lean_dec(x_373);
 lean_inc(x_292);
-x_381 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_292);
+x_381 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_292);
 x_382 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_382, 0, x_381);
 x_383 = l_Array_iterateMAux___main___at_Lean_withNestedTraces___spec__4___closed__1;
@@ -16796,7 +16796,7 @@ x_386 = lean_alloc_ctor(10, 2, 0);
 lean_ctor_set(x_386, 0, x_384);
 lean_ctor_set(x_386, 1, x_385);
 lean_inc(x_374);
-x_387 = l_Lean_fmt___at_Lean_Position_Lean_HasFormat___spec__1(x_374);
+x_387 = l_Lean_fmt___at_Lean_Position_Lean_Data_Position___instance__2___spec__1(x_374);
 x_388 = lean_alloc_ctor(0, 1, 0);
 lean_ctor_set(x_388, 0, x_387);
 x_389 = lean_alloc_ctor(10, 2, 0);
@@ -19203,7 +19203,7 @@ x_1 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___closed__1;
 x_2 = l___private_Lean_Meta_WHNF_0__Lean_Meta_cached_x3f___closed__1;
 x_3 = lean_unsigned_to_nat(413u);
 x_4 = lean_unsigned_to_nat(32u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -19424,7 +19424,7 @@ x_1 = l___private_Lean_Meta_WHNF_0__Lean_Meta_whnfEasyCases___closed__1;
 x_2 = l___private_Lean_Meta_WHNF_0__Lean_Meta_cache___closed__1;
 x_3 = lean_unsigned_to_nat(423u);
 x_4 = lean_unsigned_to_nat(32u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/Parser/Basic.c b/stage0/stdlib/Lean/Parser/Basic.c
index e597557101..821d48d87a 100644
--- a/stage0/stdlib/Lean/Parser/Basic.c
+++ b/stage0/stdlib/Lean/Parser/Basic.c
@@ -24,6 +24,7 @@ lean_object* lean_string_push(lean_object*, uint32_t);
 lean_object* l_Lean_Parser_charLit___closed__1;
 lean_object* l_Lean_Parser_andthenInfo___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Parser_Basic_4__isToken___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_hashOrelse;
 size_t l_USize_add(size_t, size_t);
 lean_object* l_Lean_Parser_manyAux___main___closed__1;
@@ -45,6 +46,7 @@ lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_octalNumberFn___s
 lean_object* l_Lean_Parser_InputContext_inhabited___closed__1;
 lean_object* lean_mk_empty_array_with_capacity(lean_object*);
 lean_object* l_Lean_Parser_sepByInfo(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_shrinkStack___boxed(lean_object*, lean_object*);
 lean_object* lean_nat_div(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_eoi___closed__2;
@@ -89,6 +91,7 @@ uint8_t l_Lean_Parser_isQuotableCharDefault(uint32_t);
 lean_object* l_Lean_Parser_charLit;
 lean_object* l_Lean_Parser_hexNumberFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_trailingLoop___main(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2(lean_object*);
 lean_object* l_Array_foldSepBy___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_numLit___elambda__1___closed__1;
 lean_object* l_Lean_Parser_longestMatchFn(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -154,8 +157,8 @@ lean_object* l_Lean_Parser_pushNone___elambda__1___boxed(lean_object*);
 lean_object* l_Lean_Parser_notFollowedByFn(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldSepByM(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_orelseFn(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4(lean_object*);
 lean_object* l_Lean_Parser_finishCommentBlock___main___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_quotedSymbol___closed__2;
 lean_object* l_Lean_Parser_mkAntiquot___closed__4;
@@ -184,6 +187,7 @@ extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l_Lean_Parser_mkCategoryParserFnExtension___lambda__1(lean_object*);
 lean_object* l_Lean_Parser_withPosition(lean_object*);
 lean_object* l_Lean_Parser_mkAntiquot___closed__11;
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_charLitFnAux(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__3;
 lean_object* l_Lean_Parser_checkPrecFn___boxed(lean_object*, lean_object*, lean_object*);
@@ -215,11 +219,9 @@ extern lean_object* l_Nat_HasOfNat___closed__1;
 lean_object* l_Lean_Parser_takeUntilFn___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strLitFnAux___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nameLitKind;
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strLit___closed__1;
 lean_object* l_Lean_Parser_unquotedSymbol___closed__2;
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_binNumberFn___spec__3___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2(lean_object*);
 lean_object* l_Lean_Parser_fieldIdx___closed__4;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_forSepArgsM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_checkPrecFn(lean_object*, lean_object*, lean_object*);
@@ -290,6 +292,7 @@ lean_object* l_Lean_Parser_unicodeSymbolInfo___elambda__1(lean_object*);
 lean_object* l_Lean_Parser_identNoAntiquot___closed__1;
 lean_object* l_Lean_Parser_ParserState_setPos(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_antiquotExpr___elambda__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3(lean_object*);
 lean_object* l_Lean_Parser_mkTokenAndFixPos___closed__1;
 lean_object* l_Lean_Parser_whitespace___boxed(lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_forSepArgsM___spec__1___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -307,13 +310,11 @@ lean_object* l_Lean_Parser_ident___closed__2;
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_HasBeq___closed__1;
 lean_object* l_Lean_Parser_nonReservedSymbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4(lean_object*);
 lean_object* l_Lean_Syntax_foldSepArgsM___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Parser_inhabited;
 lean_object* l_Lean_Parser_hasAndthen___closed__1;
 lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__6;
 lean_object* l_Lean_Parser_takeUntilFn___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_quotedSymbolFn___spec__2(uint32_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_identFnAux___main___spec__3(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_longestMatchFnAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -355,13 +356,13 @@ lean_object* l_Lean_Parser_skip___closed__1;
 lean_object* l_Lean_Syntax_foldArgsM(lean_object*, lean_object*);
 lean_object* l_Array_shrink___main___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_numLitNoAntiquot___closed__2;
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_withAntiquot(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_fieldIdx___closed__3;
 uint8_t l_Lean_Parser_Error_beq(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAntiquot___closed__26;
 lean_object* l_Lean_Parser_ParserState_keepNewError(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_antiquotExpr;
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbol(lean_object*);
 lean_object* l_Lean_Parser_isQuotableCharDefault___boxed(lean_object*);
 lean_object* l_Lean_Parser_checkLineEqFn(lean_object*, lean_object*, lean_object*);
@@ -426,6 +427,7 @@ lean_object* l_Lean_Parser_strAux___main(lean_object*, lean_object*, lean_object
 lean_object* l_Lean_Parser_mkAntiquot___closed__10;
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_chFn___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_antiquotNestedExpr___closed__5;
 lean_object* l___private_Lean_Parser_Basic_3__rawAux(lean_object*, uint8_t, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkIdResult(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -454,7 +456,7 @@ lean_object* l_Lean_Parser_withForbidden___lambda__1(lean_object*, lean_object*,
 lean_object* l_Lean_Parser_TokenMap_Inhabited(lean_object*);
 lean_object* l_Lean_Parser_rawIdent;
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepByM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6(lean_object*);
 lean_object* l_Lean_Parser_antiquotNestedExpr___elambda__1___closed__10;
 lean_object* l_Lean_Parser_FirstTokens_merge(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_many1Unbox___closed__1;
@@ -483,6 +485,7 @@ lean_object* l_Lean_Parser_satisfyFn___at_Lean_Parser_octalNumberFn___spec__1(le
 lean_object* l_Lean_Parser_orelseFnCore___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_hasError___boxed(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3(lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbol___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nodeInfo___elambda__2(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAntiquot___closed__23;
@@ -610,7 +613,6 @@ lean_object* l_Lean_Parser_Error_toString(lean_object*);
 lean_object* l_Lean_Parser_categoryParserOfStackFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_checkNoImmediateColon___elambda__1___closed__1;
 lean_object* l_Lean_Parser_runLongestMatchParser(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkTrailingNode___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_getNumArgs(lean_object*);
 lean_object* l_Array_findRevMAux___main___at___private_Lean_Parser_Basic_9__pickNonNone___spec__1(lean_object*, lean_object*, lean_object*);
@@ -621,10 +623,11 @@ lean_object* l_Std_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__5___ra
 lean_object* l_Lean_Parser_ParserState_mkUnexpectedErrorAt(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_quotedSymbolKind___closed__2;
 lean_object* l_Lean_Parser_mkAntiquot___closed__24;
+lean_object* l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1(lean_object*);
 lean_object* l_Lean_Parser_mergeOrElseErrors(lean_object*, lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_Parser_tryFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_whitespace___main___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1(lean_object*);
 lean_object* l_Lean_Parser_withPosition___lambda__1(lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
 uint8_t l_USize_decLe(size_t, size_t);
@@ -641,14 +644,12 @@ lean_object* l_Lean_Parser_mkAntiquot___closed__22;
 lean_object* l_Lean_Syntax_getArgs(lean_object*);
 lean_object* l_Lean_Syntax_getKind(lean_object*);
 lean_object* l_Lean_Parser_chFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3(lean_object*);
 lean_object* l_Lean_Parser_numLitNoAntiquot;
 lean_object* l___private_Lean_Parser_Basic_6__nameLitAux(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_beq___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_orelseInfo___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAntiquot___closed__14;
 lean_object* l_Lean_Parser_FirstTokens_toStr___closed__1;
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3(lean_object*);
 lean_object* l_Lean_Parser_setExpectedFn___boxed(lean_object*);
 lean_object* l_Lean_Parser_quotedSymbolFn___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_withResultOf(lean_object*, lean_object*);
@@ -670,7 +671,6 @@ lean_object* l_Lean_Parser_epsilonInfo___closed__3;
 lean_object* l_Lean_Parser_unquotedSymbol;
 lean_object* l___private_Lean_Parser_Basic_9__pickNonNone(lean_object*);
 lean_object* l_Lean_Parser_hashOrelse___closed__1;
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nonReservedSymbolInfo___elambda__2___boxed(lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_whitespace___main___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_categoryParser___elambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -684,12 +684,11 @@ lean_object* l_Lean_Parser_ParserCategory_inhabited;
 lean_object* l_Lean_Parser_mkAntiquot___closed__19;
 lean_object* l_Lean_Parser_unicodeSymbolFn___closed__1;
 lean_object* l_Lean_Parser_takeWhileFn___at_Lean_Parser_hexNumberFn___spec__2___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__5(lean_object*);
 lean_object* l_Lean_Parser_checkNoWsBefore___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_noFirstTokenInfo___elambda__2(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_withoutPosition(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkCategoryParserFnRef___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_epsilonInfo___closed__2;
 lean_object* l_Lean_Parser_Parser_inhabited___closed__2;
@@ -701,18 +700,16 @@ lean_object* l_Lean_Parser_nonReservedSymbolInfo___closed__1;
 lean_object* l_Array_iterateMAux___main___at_Lean_Syntax_foldArgsM___spec__1(lean_object*, lean_object*);
 lean_object* l_List_eraseReps___at_Lean_Parser_Error_toString___spec__3(lean_object*);
 lean_object* l_Lean_Parser_ParserCategory_inhabited___closed__1;
+lean_object* l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_isIdCont___boxed(lean_object*, lean_object*);
 uint8_t l_Lean_Syntax_isNone(lean_object*);
 lean_object* l_Lean_Parser_strAux___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeWhile1Fn___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_identNoAntiquot___closed__3;
 lean_object* l_Lean_Parser_epsilonInfo___closed__1;
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7(lean_object*);
 lean_object* l_Lean_Parser_checkPrec(lean_object*);
 lean_object* l_Lean_Parser_checkNoImmediateColon___closed__2;
-extern lean_object* l_Lean_FileMap_Inhabited___closed__1;
 extern lean_object* l_Lean_mkOptionalNode___closed__1;
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Array_foldSepBy___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_String_trim(lean_object*);
 lean_object* l_Lean_Parser_leadingParserAux(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*);
@@ -725,6 +722,7 @@ lean_object* l_Lean_Parser_checkWsBeforeFn___boxed(lean_object*, lean_object*, l
 lean_object* l_Lean_Parser_optionalFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_nameLitFn___closed__1;
 lean_object* l_Lean_Parser_checkOutsideQuotFn___closed__1;
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_insertAux___main___at_Lean_Parser_SyntaxNodeKindSet_insert___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_checkOutsideQuotFn___boxed(lean_object*, lean_object*);
 lean_object* lean_array_pop(lean_object*);
@@ -752,7 +750,6 @@ lean_object* l_Lean_Parser_eoiFn___closed__1;
 lean_object* l_Lean_Parser_mkAtomicInfo___closed__1;
 lean_object* l_Lean_Parser_checkColGtFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_toString___closed__3;
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1(lean_object*);
 lean_object* l_Lean_Parser_ParserState_stackSize(lean_object*);
 lean_object* l_Lean_Parser_fieldIdx;
 lean_object* l_Lean_Parser_Parser_inhabited___closed__3;
@@ -764,6 +761,7 @@ lean_object* l_Lean_Parser_mkAntiquot___elambda__1(lean_object*, lean_object*, l
 lean_object* l_Lean_Parser_categoryParserOfStackFn___closed__1;
 lean_object* l_Lean_Parser_manyFn(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_next___boxed(lean_object*, lean_object*, lean_object*);
+extern lean_object* l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1;
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
 lean_object* l_Lean_Parser_Parser_inhabited___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepArgsM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -810,7 +808,6 @@ uint8_t l_Lean_Parser_ParserState_hasError(lean_object*);
 lean_object* l_Lean_Parser_symbolFnAux(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_hexDigitFn___closed__1;
 lean_object* l_Lean_Parser_mkAtom(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6(lean_object*);
 lean_object* l_Lean_Parser_ParserState_mkEOIError(lean_object*);
 lean_object* l_Lean_Parser_unicodeSymbolFnAux___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ident___closed__3;
@@ -838,7 +835,7 @@ lean_object* l_Lean_Parser_longestMatchStep___boxed(lean_object*, lean_object*,
 lean_object* l_Lean_Parser_quotedCharCoreFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_foldlStepMAux___main___at_Lean_Syntax_foldSepRevArgsM___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Error_toString___closed__1;
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAntiquot___closed__2;
 lean_object* l_Lean_Parser_withResultOfInfo(lean_object*);
 lean_object* l_Lean_Parser_Parser_inhabited___closed__1;
@@ -846,6 +843,7 @@ lean_object* l_Lean_Syntax_getTailInfo___main(lean_object*);
 lean_object* l_Lean_Parser_categoryParserOfStack___elambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_stringToParserCoeOld(lean_object*);
 lean_object* l_Lean_Parser_identFn(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_takeUntilFn___main___at_Lean_Parser_decimalNumberFn___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Array_qsortAux___main___at_Lean_Parser_Error_toString___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_Basic_3__iterateRevMAux___main___at_Lean_Syntax_foldSepRevArgs___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -858,8 +856,11 @@ lean_object* l_Lean_Parser_nameLit___elambda__1___closed__2;
 lean_object* l_Lean_Parser_checkColGtFn___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_sepBy1Info___elambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_rawIdent___elambda__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_strLit;
 lean_object* l_Lean_Parser_many1(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7(lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_Parser_TokenMap_insert___spec__2(lean_object*);
 lean_object* l_Lean_Parser_mkAtomicInfo___closed__2;
 lean_object* l_Lean_Parser_sepBy___boxed(lean_object*, lean_object*, lean_object*);
@@ -883,7 +884,6 @@ lean_object* l_Lean_Parser_mkAntiquot___boxed(lean_object*, lean_object*, lean_o
 lean_object* l_Lean_Parser_longestMatchFnAux___main(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_error(lean_object*);
 uint8_t l_Lean_Syntax_isIdent(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkAntiquot___closed__1;
 lean_object* l_Lean_Parser_ParserFn_inhabited___boxed(lean_object*);
 lean_object* l_Lean_Parser_andthenFn(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -1582,7 +1582,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_String_splitAux___main___closed__1;
-x_2 = l_Lean_FileMap_Inhabited___closed__1;
+x_2 = l_Lean_FileMap_Lean_Data_Position___instance__5___closed__1;
 x_3 = lean_alloc_ctor(0, 3, 0);
 lean_ctor_set(x_3, 0, x_1);
 lean_ctor_set(x_3, 1, x_1);
@@ -13830,7 +13830,7 @@ x_1 = l_Lean_Parser_eoi___closed__2;
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -13873,2388 +13873,2465 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = l_Lean_Name_quickLt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = l_Lean_Name_quickLt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = l_Lean_Name_quickLt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = l_Lean_Name_quickLt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = l_Lean_Name_quickLt(x_2, x_17);
-if (x_20 == 0)
+x_24 = l_Lean_Name_quickLt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = l_Lean_Name_quickLt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = l_Lean_Name_quickLt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = l_Lean_Name_quickLt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = l_Lean_Name_quickLt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = l_Lean_Name_quickLt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = l_Lean_Name_quickLt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = l_Lean_Name_quickLt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = l_Lean_Name_quickLt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = l_Lean_Name_quickLt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = l_Lean_Name_quickLt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -16266,2388 +16343,2465 @@ return x_477;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = l_Lean_Name_quickLt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = l_Lean_Name_quickLt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = l_Lean_Name_quickLt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = l_Lean_Name_quickLt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = l_Lean_Name_quickLt(x_2, x_17);
-if (x_20 == 0)
+x_24 = l_Lean_Name_quickLt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = l_Lean_Name_quickLt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = l_Lean_Name_quickLt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = l_Lean_Name_quickLt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = l_Lean_Name_quickLt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = l_Lean_Name_quickLt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = l_Lean_Name_quickLt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = l_Lean_Name_quickLt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = l_Lean_Name_quickLt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = l_Lean_Name_quickLt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = l_Lean_Name_quickLt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -18659,11 +18813,11 @@ return x_477;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg), 3, 0);
 return x_2;
 }
 }
@@ -18675,13 +18829,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__3___rarg(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__4___rarg(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -18695,2380 +18849,2457 @@ x_2 = lean_alloc_closure((void*)(l_Std_RBNode_insert___at_Lean_Parser_TokenMap_i
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = l_Lean_Name_quickLt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = l_Lean_Name_quickLt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = l_Lean_Name_quickLt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = l_Lean_Name_quickLt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = l_Lean_Name_quickLt(x_2, x_17);
-if (x_20 == 0)
+x_24 = l_Lean_Name_quickLt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = l_Lean_Name_quickLt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = l_Lean_Name_quickLt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = l_Lean_Name_quickLt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = l_Lean_Name_quickLt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = l_Lean_Name_quickLt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = l_Lean_Name_quickLt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = l_Lean_Name_quickLt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = l_Lean_Name_quickLt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = l_Lean_Name_quickLt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = l_Lean_Name_quickLt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -21080,2388 +21311,2465 @@ return x_477;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = l_Lean_Name_quickLt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = l_Lean_Name_quickLt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = l_Lean_Name_quickLt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = l_Lean_Name_quickLt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = l_Lean_Name_quickLt(x_2, x_17);
-if (x_20 == 0)
+x_24 = l_Lean_Name_quickLt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = l_Lean_Name_quickLt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = l_Lean_Name_quickLt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = l_Lean_Name_quickLt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = l_Lean_Name_quickLt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = l_Lean_Name_quickLt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = l_Lean_Name_quickLt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = l_Lean_Name_quickLt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = l_Lean_Name_quickLt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = l_Lean_Name_quickLt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = l_Lean_Name_quickLt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -23473,11 +23781,11 @@ return x_477;
 }
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7(lean_object* x_1) {
+lean_object* l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg), 3, 0);
 return x_2;
 }
 }
@@ -23489,13 +23797,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__6___rarg(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_Parser_TokenMap_insert___spec__7___rarg(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -23513,7 +23821,7 @@ lean_object* l_Lean_Parser_TokenMap_insert___rarg(lean_object* x_1, lean_object*
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg(x_1, x_2);
+x_4 = l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1___rarg(x_1, x_2);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
@@ -23546,11 +23854,11 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Parser_TokenMap_insert___rarg), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Parser_TokenMap_insert___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Parser_TokenMap_insert___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -23614,7 +23922,7 @@ x_1 = l_Lean_Parser_ParserCategory_inhabited___closed__1;
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -23657,15 +23965,15 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -23708,15 +24016,15 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2___rarg___boxed), 2, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -23759,11 +24067,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3(lean_object* x_1) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -23881,7 +24189,7 @@ lean_object* x_26; lean_object* x_27;
 x_26 = lean_ctor_get(x_18, 2);
 lean_inc(x_26);
 lean_dec(x_18);
-x_27 = l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg(x_1, x_26);
+x_27 = l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2___rarg(x_1, x_26);
 lean_dec(x_26);
 if (lean_obj_tag(x_27) == 0)
 {
@@ -23898,7 +24206,7 @@ x_29 = lean_ctor_get(x_27, 0);
 lean_inc(x_29);
 lean_dec(x_27);
 x_30 = l_Lean_identKind;
-x_31 = l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg(x_1, x_30);
+x_31 = l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3___rarg(x_1, x_30);
 if (lean_obj_tag(x_31) == 0)
 {
 lean_object* x_32; 
@@ -23927,7 +24235,7 @@ return x_35;
 block_15:
 {
 lean_object* x_10; 
-x_10 = l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg(x_1, x_9);
+x_10 = l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1___rarg(x_1, x_9);
 lean_dec(x_9);
 if (lean_obj_tag(x_10) == 0)
 {
@@ -23969,31 +24277,31 @@ x_2 = lean_alloc_closure((void*)(l_Lean_Parser_indexed___rarg___boxed), 4, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Parser_indexed___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__2___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Parser_indexed___spec__2___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Parser_indexed___spec__3___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Parser_indexed___spec__3___rarg(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Parser/Extension.c b/stage0/stdlib/Lean/Parser/Extension.c
index 8867180474..aec582a621 100644
--- a/stage0/stdlib/Lean/Parser/Extension.c
+++ b/stage0/stdlib/Lean/Parser/Extension.c
@@ -166,7 +166,6 @@ lean_object* l_Lean_Parser_declareTrailingBuiltinParser___closed__2;
 lean_object* l_Lean_Parser_initCacheForInput(lean_object*);
 lean_object* l_Lean_Parser_addSyntaxNodeKind(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_registerRunParserAttributeHooksAttribute___lambda__1___closed__2;
-extern lean_object* l_Lean_Parser_Trie_HasEmptyc___closed__1;
 lean_object* l_Lean_getConstInfo___at_Lean_KeyedDeclsAttribute_init___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_Parser_Extension_11__BuiltinParserAttribute_add___closed__3;
@@ -204,10 +203,10 @@ lean_object* l_Lean_Name_append___main(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_commandParser(lean_object*);
 lean_object* l_Lean_Parser_notFollowedByTermToken___closed__2;
 lean_object* l_Std_PersistentHashMap_findAux___main___at_Lean_Parser_getCategory___spec__2(lean_object*, size_t, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_ofExcept___at___private_Lean_Parser_Extension_11__BuiltinParserAttribute_add___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_nameToExpr___closed__1;
 lean_object* l_Lean_Parser_registerRunBuiltinParserAttributeHooksAttribute(lean_object*);
+extern lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1;
 lean_object* l_Lean_Parser_regTermParserAttribute___closed__1;
 lean_object* l_Lean_Parser_mkParserExtension___closed__8;
 lean_object* l_Lean_Parser_whitespace___main(lean_object*, lean_object*);
@@ -270,6 +269,7 @@ extern lean_object* l_IO_Error_Inhabited___closed__1;
 lean_object* l_Lean_Parser_compileParserDescr___main___closed__1;
 lean_object* l_Lean_Parser_addParserCategory___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_registerBuiltinParserAttribute(lean_object*, lean_object*, uint8_t, lean_object*);
+lean_object* l_Lean_Parser_Trie_insert_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserOfConstantAux(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_getCategory___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_registerBuiltinAttribute(lean_object*, lean_object*);
@@ -286,11 +286,9 @@ lean_object* l_Lean_Parser_getParserPriority___closed__2;
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_isValidSyntaxNodeKind___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_notFollowedByCategoryTokenFn(lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Data_Trie_2__insertAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension(lean_object*);
 lean_object* l_Lean_Parser_sepByFn___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkBuiltinTokenTable(lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_addTrailingParser(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_forM___main___at___private_Lean_Parser_Extension_12__ParserAttribute_add___spec__1___closed__4;
 lean_object* l_Lean_ConstantInfo_type(lean_object*);
@@ -342,6 +340,7 @@ lean_object* l_Lean_Parser_categoryParser(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_categoryParserFnImpl___closed__3;
 lean_object* l_Lean_Environment_addAndCompile(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_mkParserAttributeImpl___elambda__1___rarg(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(lean_object*, lean_object*);
 uint8_t l_Lean_Parser_isValidSyntaxNodeKind(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_runParserCategory(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_Parser_getSyntaxNodeKinds___spec__4(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -350,6 +349,7 @@ extern lean_object* l_Std_PersistentHashMap_mkCollisionNode___rarg___closed__1;
 lean_object* l_Lean_Name_toExprAux___main(lean_object*);
 lean_object* l_Lean_Parser_mkParserExtension___closed__5;
 lean_object* l_List_forM___main___at___private_Lean_Parser_Extension_12__ParserAttribute_add___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_symbolInfo(lean_object*);
 lean_object* l_Lean_Parser_parserAttributeHooks;
 lean_object* l___private_Lean_Parser_Extension_13__registerParserAttributeImplBuilder(lean_object*);
@@ -439,7 +439,6 @@ lean_object* l_Lean_Parser_regBuiltinTermParserAttr___closed__2;
 lean_object* l_Std_PersistentHashMap_insertAtCollisionNodeAux___main___at___private_Lean_Parser_Extension_3__addParserCategoryCore___spec__5(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_compileParserDescr___main___closed__4;
 extern lean_object* l_Lean_Parser_Parser_inhabited___closed__1;
-lean_object* l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_ofExcept___at___private_Lean_Parser_Extension_10__ParserExtension_addImported___spec__2(lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_containsAux___main___at___private_Lean_Parser_Extension_3__addParserCategoryCore___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Lean_Parser_addLeadingParser___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -447,6 +446,7 @@ lean_object* l___private_Lean_Parser_Extension_10__ParserExtension_addImported(l
 extern lean_object* l_Lean_mkAppStx___closed__1;
 lean_object* l_Lean_Parser_regBuiltinCommandParserAttr___closed__3;
 lean_object* l_List_forM___main___at___private_Lean_Parser_Extension_12__ParserAttribute_add___spec__1___closed__5;
+lean_object* l_Lean_Parser_Trie_find_x3f_loop___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_getCategory(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_strLit;
 lean_object* l_IO_ofExcept___at___private_Lean_Parser_Extension_4__addBuiltinParserCategory___spec__1(lean_object*, lean_object*);
@@ -489,7 +489,7 @@ lean_object* l_Lean_Parser_mkBuiltinTokenTable(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
-x_2 = l_Lean_Parser_Trie_HasEmptyc___closed__1;
+x_2 = l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1;
 x_3 = l_IO_mkRef___at_Lean_Parser_mkBuiltinTokenTable___spec__1(x_2, x_1);
 return x_3;
 }
@@ -1434,7 +1434,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Parser_Trie_HasEmptyc___closed__1;
+x_2 = l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1;
 x_3 = l_Lean_LocalContext_Inhabited___closed__1;
 x_4 = lean_alloc_ctor(0, 4, 0);
 lean_ctor_set(x_4, 0, x_2);
@@ -1536,12 +1536,12 @@ if (x_4 == 0)
 lean_object* x_5; lean_object* x_6; 
 x_5 = lean_unsigned_to_nat(0u);
 lean_inc(x_1);
-x_6 = l___private_Lean_Data_Trie_3__findAux_x3f___main___rarg(x_2, x_1, x_5);
+x_6 = l_Lean_Parser_Trie_find_x3f_loop___rarg(x_2, x_1, x_5);
 if (lean_obj_tag(x_6) == 0)
 {
 lean_object* x_7; lean_object* x_8; 
 lean_inc(x_2);
-x_7 = l___private_Lean_Data_Trie_2__insertAux___main___rarg(x_2, x_2, x_1, x_5);
+x_7 = l_Lean_Parser_Trie_insert_loop___rarg(x_2, x_2, x_1, x_5);
 lean_dec(x_2);
 x_8 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_8, 0, x_7);
@@ -2410,7 +2410,7 @@ _start:
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
 x_4 = l_Lean_Parser_builtinTokenTable;
-x_5 = l_Lean_Parser_Trie_HasEmptyc___closed__1;
+x_5 = l_Lean_Parser_Trie_Lean_Data_Trie___instance__1___closed__1;
 x_6 = lean_st_ref_swap(x_4, x_5, x_3);
 x_7 = !lean_is_exclusive(x_6);
 if (x_7 == 0)
@@ -9869,7 +9869,7 @@ x_3 = l_Lean_Parser_categoryParser(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -10023,7 +10023,7 @@ lean_inc(x_26);
 lean_dec(x_25);
 x_27 = lean_box(0);
 x_28 = lean_name_mk_string(x_27, x_24);
-x_29 = l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_26, x_28);
+x_29 = l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_26, x_28);
 lean_dec(x_28);
 lean_dec(x_26);
 if (lean_obj_tag(x_29) == 0)
@@ -10063,7 +10063,7 @@ lean_inc(x_38);
 lean_dec(x_37);
 x_39 = lean_box(0);
 x_40 = lean_name_mk_string(x_39, x_34);
-x_41 = l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_38, x_40);
+x_41 = l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_38, x_40);
 lean_dec(x_40);
 lean_dec(x_38);
 if (lean_obj_tag(x_41) == 0)
@@ -10187,7 +10187,7 @@ lean_inc(x_63);
 lean_dec(x_62);
 x_64 = lean_box(0);
 x_65 = lean_name_mk_string(x_64, x_61);
-x_66 = l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_63, x_65);
+x_66 = l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_63, x_65);
 lean_dec(x_65);
 lean_dec(x_63);
 if (lean_obj_tag(x_66) == 0)
@@ -10227,7 +10227,7 @@ lean_inc(x_75);
 lean_dec(x_74);
 x_76 = lean_box(0);
 x_77 = lean_name_mk_string(x_76, x_71);
-x_78 = l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_75, x_77);
+x_78 = l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_75, x_77);
 lean_dec(x_77);
 lean_dec(x_75);
 if (lean_obj_tag(x_78) == 0)
@@ -10272,11 +10272,11 @@ return x_82;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Parser_notFollowedByCategoryTokenFn___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/Parser/Module.c b/stage0/stdlib/Lean/Parser/Module.c
index ba696198fd..918d72c1c7 100644
--- a/stage0/stdlib/Lean/Parser/Module.c
+++ b/stage0/stdlib/Lean/Parser/Module.c
@@ -38,6 +38,7 @@ lean_object* l_Lean_Parser_parseHeader(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Module_module___closed__7;
 lean_object* l_Lean_PrettyPrinter_Formatter_many_formatter(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ModuleParserState_inhabited___closed__1;
+lean_object* l_IO_realPath___at_Lean_Parser_parseModule___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Format_pretty(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_regBuiltinCommandParserAttr___closed__4;
 lean_object* l_IO_print___at_Lean_HasRepr_hasEval___spec__2(lean_object*, lean_object*);
@@ -178,7 +179,6 @@ uint8_t l_Std_PersistentArray_isEmpty___rarg(lean_object*);
 lean_object* l_Lean_Parser_Module_header_parenthesizer___closed__1;
 lean_object* l_Lean_Parser_Module_header_formatter___closed__9;
 lean_object* l_Lean_Parser_Module_module_formatter___closed__10;
-lean_object* l_Lean_Parser_Trie_Inhabited(lean_object*);
 extern lean_object* l_Lean_PrettyPrinter_Parenthesizer_maybeParenthesize___closed__12;
 lean_object* l_IO_FS_readFile___at_Lean_Parser_parseFile___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_ParserState_restore(lean_object*, lean_object*, lean_object*);
@@ -287,6 +287,7 @@ lean_object* l_Lean_Parser_Module_module_formatter___closed__6;
 lean_object* l_Lean_PrettyPrinter_Parenthesizer_many_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_prim_handle_mk(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_forM___at___private_Lean_Parser_Module_4__testModuleParserAux___main___spec__3(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Parser_Trie_Lean_Data_Trie___instance__2(lean_object*);
 lean_object* l_Lean_Parser_Module_prelude___elambda__1___closed__4;
 lean_object* l_Lean_Parser_Module_import___elambda__1___closed__6;
 lean_object* l___private_Lean_Parser_Module_4__testModuleParserAux___main(lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*);
@@ -3181,7 +3182,7 @@ static lean_object* _init_l_Lean_Parser_Module_updateTokens___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = l_Lean_Parser_Trie_Inhabited(lean_box(0));
+x_1 = l_Lean_Parser_Trie_Lean_Data_Trie___instance__2(lean_box(0));
 return x_1;
 }
 }
@@ -4936,6 +4937,14 @@ x_7 = l_Lean_Parser_parseModuleAux___main(x_1, x_2, x_3, x_4, x_5, x_6);
 return x_7;
 }
 }
+lean_object* l_IO_realPath___at_Lean_Parser_parseModule___spec__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_io_realpath(x_1, x_2);
+return x_3;
+}
+}
 lean_object* l_Lean_Parser_parseModule(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
diff --git a/stage0/stdlib/Lean/Parser/Term.c b/stage0/stdlib/Lean/Parser/Term.c
index ad99523965..66e0f3750c 100644
--- a/stage0/stdlib/Lean/Parser/Term.c
+++ b/stage0/stdlib/Lean/Parser/Term.c
@@ -436,6 +436,7 @@ lean_object* l_Lean_Parser_Term_ensureExpectedType___elambda__1___closed__2;
 lean_object* l_Lean_Parser_Term_nativeRefl_parenthesizer___closed__1;
 lean_object* l_Lean_Parser_Term_matchAlt___closed__8;
 lean_object* l___regBuiltinParser_Lean_Parser_Term_assert(lean_object*);
+extern lean_object* l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2;
 lean_object* l_Lean_Parser_Term_prod___elambda__1(lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_forall_parenthesizer(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Parser_Term_namedPattern_formatter(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -2572,7 +2573,6 @@ lean_object* l_Lean_Parser_Term_cons___closed__1;
 extern lean_object* l_Lean_Parser_antiquotNestedExpr_formatter___closed__2;
 lean_object* l_Lean_Parser_Term_arrow_formatter___closed__1;
 lean_object* l_Lean_Parser_Term_if___elambda__1___closed__1;
-extern lean_object* l_Lean_OpenDecl_HasToString___closed__2;
 lean_object* l_Lean_Parser_Term_binderDefault___closed__4;
 lean_object* l_Lean_Parser_Term_show_formatter___closed__5;
 lean_object* l_Lean_Parser_Term_inaccessible_formatter___closed__4;
@@ -36528,7 +36528,7 @@ static lean_object* _init_l_Lean_Parser_Term_depArrow___elambda__1___closed__6()
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
-x_1 = l_Lean_OpenDecl_HasToString___closed__2;
+x_1 = l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2;
 x_2 = l_String_trim(x_1);
 return x_2;
 }
@@ -37448,7 +37448,7 @@ static lean_object* _init_l_Lean_Parser_Term_depArrow_formatter___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l_Lean_OpenDecl_HasToString___closed__2;
+x_1 = l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2;
 x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7;
 x_3 = lean_alloc_closure((void*)(l_Lean_PrettyPrinter_Formatter_unicodeSymbol_formatter___boxed), 7, 2);
 lean_closure_set(x_3, 0, x_1);
@@ -65578,7 +65578,7 @@ static lean_object* _init_l_Lean_Parser_Term_arrow___elambda__1___closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_OpenDecl_HasToString___closed__2;
+x_1 = l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2;
 x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7;
 x_3 = lean_unsigned_to_nat(25u);
 x_4 = l_Lean_Parser_Term_unicodeInfixR(x_1, x_2, x_3);
@@ -65710,7 +65710,7 @@ static lean_object* _init_l_Lean_Parser_Term_arrow_formatter___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_OpenDecl_HasToString___closed__2;
+x_1 = l_Lean_OpenDecl_Lean_Data_OpenDecl___instance__2___closed__2;
 x_2 = l_Lean_Parser_Term_depArrow___elambda__1___closed__7;
 x_3 = lean_unsigned_to_nat(25u);
 x_4 = lean_alloc_closure((void*)(l_Lean_Parser_Term_unicodeInfixR_formatter___boxed), 8, 3);
diff --git a/stage0/stdlib/Lean/ParserCompiler/Attribute.c b/stage0/stdlib/Lean/ParserCompiler/Attribute.c
index 80768f99fc..7965809204 100644
--- a/stage0/stdlib/Lean/ParserCompiler/Attribute.c
+++ b/stage0/stdlib/Lean/ParserCompiler/Attribute.c
@@ -58,9 +58,9 @@ extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed_
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___at_Lean_ParserCompiler_registerCombinatorAttribute___spec__5(lean_object*, lean_object*);
 lean_object* l_Lean_ParserCompiler_CombinatorAttribute_Inhabited___closed__1;
+lean_object* l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___closed__1;
 extern lean_object* l_Lean_registerParametricAttribute___rarg___closed__3;
-lean_object* l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_throwError___at_Lean_addAttribute___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ParserCompiler_registerCombinatorAttribute___lambda__1___closed__6;
@@ -935,7 +935,7 @@ _start:
 lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_4 = lean_ctor_get(x_1, 1);
 x_5 = l_Lean_SimplePersistentEnvExtension_getState___rarg(x_4, x_2);
-x_6 = l_Std_RBNode_find___main___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_5, x_3);
+x_6 = l_Std_RBNode_find___at___private_Lean_Hygiene_4__sanitizeSyntaxAux___main___spec__2(x_5, x_3);
 lean_dec(x_5);
 return x_6;
 }
diff --git a/stage0/stdlib/Lean/ProjFns.c b/stage0/stdlib/Lean/ProjFns.c
index 316729c4a9..2841a8b39d 100644
--- a/stage0/stdlib/Lean/ProjFns.c
+++ b/stage0/stdlib/Lean/ProjFns.c
@@ -39,14 +39,12 @@ uint8_t l_Lean_NameMap_contains___rarg(lean_object*, lean_object*);
 uint8_t l_Lean_Environment_isProjectionFn(lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* lean_get_projection_info(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_getProjectionStructureName_x3f(lean_object*, lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_projectionFnInfoExt___elambda__3___boxed(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Environment_8__persistentEnvExtensionsRef;
 lean_object* l_Lean_projectionFnInfoExt___elambda__4___rarg(lean_object*);
 lean_object* l_Array_binSearchAux___main___at_Lean_Environment_isProjectionFn___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkProjectionFnInfoExtension___lambda__1(lean_object*, lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
@@ -83,6 +81,7 @@ lean_object* l_Lean_projectionFnInfoExt___elambda__1(lean_object*);
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__1;
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_ProjectionFunctionInfo_fromClassEx___boxed(lean_object*);
 extern lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___closed__1;
 lean_object* l_Lean_mkProjectionInfoEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -96,6 +95,7 @@ lean_object* l_Lean_projectionFnInfoExt___elambda__4(lean_object*, lean_object*)
 lean_object* l_Array_binSearchAux___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_projectionFnInfoExt___closed__4;
 extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed__2;
+lean_object* l_Std_RBNode_find___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_isProjectionFn___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_projectionFnInfoExt___closed__2;
 lean_object* l_List_toArrayAux___main___rarg(lean_object*, lean_object*);
@@ -1044,7 +1044,7 @@ x_8 = lean_add_projection_info(x_1, x_2, x_3, x_4, x_5, x_7);
 return x_8;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -1179,7 +1179,7 @@ lean_object* x_4; lean_object* x_5; lean_object* x_6;
 x_4 = l_Lean_projectionFnInfoExt;
 x_5 = l_Lean_SimplePersistentEnvExtension_getState___rarg(x_4, x_1);
 lean_dec(x_1);
-x_6 = l_Std_RBNode_find___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(x_5, x_2);
+x_6 = l_Std_RBNode_find___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(x_5, x_2);
 lean_dec(x_2);
 lean_dec(x_5);
 return x_6;
@@ -1243,11 +1243,11 @@ return x_23;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Environment_getProjectionFnInfo_x3f___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/ReducibilityAttrs.c b/stage0/stdlib/Lean/ReducibilityAttrs.c
index effcd2afce..9b0b77e4a4 100644
--- a/stage0/stdlib/Lean/ReducibilityAttrs.c
+++ b/stage0/stdlib/Lean/ReducibilityAttrs.c
@@ -19,7 +19,6 @@ lean_object* l_Lean_mkReducibilityAttrs___closed__14;
 lean_object* l_Array_qsortAux___main___at_Lean_mkReducibilityAttrs___spec__3(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Name_quickLt(lean_object*, lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_mkReducibilityAttrs___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_mkReducibilityAttrs___closed__16;
 extern lean_object* l_Lean_registerInternalExceptionId___closed__2;
 lean_object* l_Lean_EnvExtensionInterfaceUnsafe_registerExt___rarg(lean_object*, lean_object*);
@@ -33,12 +32,13 @@ lean_object* lean_array_get_size(lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 extern lean_object* l_Lean_Name_inhabited;
 lean_object* l_Lean_setEnv___at_Lean_registerTagAttribute___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_getReducibilityStatus___spec__2___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_mkReducibilityAttrs___spec__2(lean_object*, lean_object*);
 uint8_t l_Lean_isReducible(lean_object*, lean_object*);
 lean_object* l_Lean_isReducible___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_mkReducibilityAttrs___closed__2;
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_mkReducibilityAttrs___closed__1;
+lean_object* l_Std_RBNode_find___at_Lean_getReducibilityStatus___spec__2___boxed(lean_object*, lean_object*);
 extern lean_object* l___private_Lean_Environment_8__persistentEnvExtensionsRef;
 lean_object* l_Array_binSearchAux___main___at_Lean_getReducibilityStatus___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_reducibilityAttrs;
@@ -57,7 +57,6 @@ lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkReducibilityAttrs___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___at_Lean_NameMap_insert___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t lean_get_reducibility_status(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_getReducibilityStatus___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_mkReducibilityAttrs___closed__18;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_mkReducibilityAttrs___closed__5;
@@ -82,6 +81,7 @@ extern lean_object* l_Lean_registerPersistentEnvExtensionUnsafe___rarg___closed_
 extern lean_object* l_Lean_EnumAttributes_Inhabited___closed__1;
 lean_object* l_Lean_mkReducibilityAttrs___closed__7;
 uint8_t lean_nat_dec_le(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Lean_mkReducibilityAttrs___spec__2___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_registerEnumAttributes___rarg___closed__1;
 lean_object* l_Lean_mkReducibilityAttrs___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_anyRangeMAux___main___at_Lean_mkReducibilityAttrs___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -92,7 +92,6 @@ lean_object* l_Lean_throwError___at_Lean_addAttribute___spec__2___rarg(lean_obje
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkReducibilityAttrs(lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_mkReducibilityAttrs___spec__1(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Lean_mkReducibilityAttrs___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Environment_getModuleIdxFor_x3f(lean_object*, lean_object*);
 lean_object* lean_set_reducibility_status(lean_object*, lean_object*, uint8_t);
 lean_object* l_Lean_mkReducibilityAttrs___closed__10;
@@ -111,6 +110,7 @@ lean_object* l_Lean_registerEnumAttributes___at_Lean_mkReducibilityAttrs___spec_
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_mkReducibilityAttrs___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_registerEnumAttributes___at_Lean_mkReducibilityAttrs___spec__1___closed__1;
 lean_object* l_Lean_registerEnumAttributes___at_Lean_mkReducibilityAttrs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_getReducibilityStatus___spec__2(lean_object*, lean_object*);
 lean_object* l___private_Init_Data_Array_QSort_1__qpartitionAux___main___at_Lean_mkReducibilityAttrs___spec__4___closed__1;
 lean_object* l_List_map___main___at_Lean_mkReducibilityAttrs___spec__7___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
@@ -122,7 +122,7 @@ x_1 = 1;
 return x_1;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_mkReducibilityAttrs___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_mkReducibilityAttrs___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -136,7 +136,7 @@ x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 1);
 x_5 = lean_ctor_get(x_2, 2);
 x_6 = lean_ctor_get(x_2, 3);
-x_7 = l_Std_RBNode_fold___main___at_Lean_mkReducibilityAttrs___spec__2(x_1, x_3);
+x_7 = l_Std_RBNode_fold___at_Lean_mkReducibilityAttrs___spec__2(x_1, x_3);
 lean_inc(x_5);
 lean_inc(x_4);
 x_8 = lean_alloc_ctor(0, 2, 0);
@@ -951,7 +951,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_2 = l_Array_empty___closed__1;
-x_3 = l_Std_RBNode_fold___main___at_Lean_mkReducibilityAttrs___spec__2(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Lean_mkReducibilityAttrs___spec__2(x_2, x_1);
 x_4 = lean_array_get_size(x_3);
 x_5 = lean_unsigned_to_nat(1u);
 x_6 = lean_nat_sub(x_4, x_5);
@@ -1302,11 +1302,11 @@ x_6 = l_Lean_registerEnumAttributes___at_Lean_mkReducibilityAttrs___spec__1(x_2,
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Lean_mkReducibilityAttrs___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Lean_mkReducibilityAttrs___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Lean_mkReducibilityAttrs___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Lean_mkReducibilityAttrs___spec__2(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -1399,7 +1399,7 @@ lean_dec(x_1);
 return x_8;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getReducibilityStatus___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_getReducibilityStatus___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -1533,7 +1533,7 @@ if (lean_obj_tag(x_4) == 0)
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_1, 1);
 x_6 = l_Lean_PersistentEnvExtension_getState___rarg(x_5, x_2);
-x_7 = l_Std_RBNode_find___main___at_Lean_getReducibilityStatus___spec__2(x_6, x_3);
+x_7 = l_Std_RBNode_find___at_Lean_getReducibilityStatus___spec__2(x_6, x_3);
 lean_dec(x_3);
 lean_dec(x_6);
 return x_7;
@@ -1622,11 +1622,11 @@ return x_7;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_getReducibilityStatus___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_getReducibilityStatus___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_getReducibilityStatus___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_getReducibilityStatus___spec__2(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
diff --git a/stage0/stdlib/Lean/ResolveName.c b/stage0/stdlib/Lean/ResolveName.c
index 2e4d7276e8..3b566c3e7c 100644
--- a/stage0/stdlib/Lean/ResolveName.c
+++ b/stage0/stdlib/Lean/ResolveName.c
@@ -18,6 +18,7 @@ lean_object* l_Std_HashMapImp_expand___at_Lean_addAliasEntry___spec__14(lean_obj
 lean_object* l_Array_iterateMAux___main___at_Lean_initFn____x40_Lean_ResolveName___hyg_53____spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_extractMacroScopes(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_ResolveName_resolveGlobalName_loop_match__4(lean_object*);
 extern lean_object* l_Lean_rootNamespace;
 lean_object* l_Lean_aliasExtension___elambda__1___boxed(lean_object*);
@@ -125,7 +126,6 @@ lean_object* l_Lean_resolveNamespace___rarg___lambda__2(lean_object*, lean_objec
 lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_ResolveName___hyg_53____closed__1;
 lean_object* l_Lean_registerSimplePersistentEnvExtension___rarg___lambda__3(lean_object*, lean_object*);
-lean_object* l_Lean_ResolveName_resolveNamespaceUsingScope___closed__4;
 lean_object* lean_array_get(lean_object*, lean_object*, lean_object*);
 lean_object* l___private_Lean_ResolveName_0__Lean_ResolveName_resolveOpenDecls_match__1(lean_object*);
 lean_object* l_Lean_resolveGlobalName___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -171,7 +171,6 @@ lean_object* l_Lean_getAliases(lean_object*, lean_object*);
 lean_object* l_Lean_ResolveName_resolveNamespace_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_findAtAux___main___at_Lean_addAliasEntry___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_initFn____x40_Lean_ResolveName___hyg_53____closed__3;
-lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentHashMap_foldlM___at_Lean_getRevAliases___spec__4___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_getRevAliases___spec__6___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_PersistentEnvExtension_addEntry___rarg(lean_object*, lean_object*, lean_object*);
@@ -265,6 +264,7 @@ lean_object* l___private_Lean_ResolveName_0__Lean_ResolveName_resolveExact(lean_
 lean_object* l_Std_HashMapImp_insert___at_Lean_addAliasEntry___spec__12(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_iterateMAux___main___at_Lean_getRevAliases___spec__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_mkConst(lean_object*, lean_object*);
+lean_object* l_Lean_Name_replacePrefix(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_resolveGlobalConst___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_ResolveName_resolveGlobalName_loop_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_resolveGlobalConst_match__1(lean_object*);
@@ -1326,54 +1326,60 @@ uint8_t x_5;
 x_5 = !lean_is_exclusive(x_1);
 if (x_5 == 0)
 {
-lean_object* x_6; lean_object* x_7; 
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = l_Std_PersistentHashMap_insert___at_Lean_addAliasEntry___spec__8(x_6, x_2, x_3);
+x_8 = 0;
 lean_ctor_set(x_1, 1, x_7);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_8);
 return x_1;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
 lean_inc(x_9);
-lean_inc(x_8);
 lean_dec(x_1);
-x_10 = l_Std_PersistentHashMap_insert___at_Lean_addAliasEntry___spec__8(x_9, x_2, x_3);
-x_11 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_11, 0, x_8);
-lean_ctor_set(x_11, 1, x_10);
-lean_ctor_set_uint8(x_11, sizeof(void*)*2, x_4);
-return x_11;
+x_11 = l_Std_PersistentHashMap_insert___at_Lean_addAliasEntry___spec__8(x_10, x_2, x_3);
+x_12 = 0;
+x_13 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_13, 0, x_9);
+lean_ctor_set(x_13, 1, x_11);
+lean_ctor_set_uint8(x_13, sizeof(void*)*2, x_12);
+return x_13;
 }
 }
 else
 {
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_1);
-if (x_12 == 0)
+uint8_t x_14; 
+x_14 = !lean_is_exclusive(x_1);
+if (x_14 == 0)
 {
-lean_object* x_13; lean_object* x_14; 
-x_13 = lean_ctor_get(x_1, 0);
-x_14 = l_Std_HashMapImp_insert___at_Lean_addAliasEntry___spec__12(x_13, x_2, x_3);
-lean_ctor_set(x_1, 0, x_14);
+lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_15 = lean_ctor_get(x_1, 0);
+x_16 = l_Std_HashMapImp_insert___at_Lean_addAliasEntry___spec__12(x_15, x_2, x_3);
+x_17 = 1;
+lean_ctor_set(x_1, 0, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*2, x_17);
 return x_1;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_1, 0);
-x_16 = lean_ctor_get(x_1, 1);
-lean_inc(x_16);
-lean_inc(x_15);
+lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; 
+x_18 = lean_ctor_get(x_1, 0);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+lean_inc(x_18);
 lean_dec(x_1);
-x_17 = l_Std_HashMapImp_insert___at_Lean_addAliasEntry___spec__12(x_15, x_2, x_3);
-x_18 = lean_alloc_ctor(0, 2, 1);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_18, 1, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*2, x_4);
-return x_18;
+x_20 = l_Std_HashMapImp_insert___at_Lean_addAliasEntry___spec__12(x_18, x_2, x_3);
+x_21 = 1;
+x_22 = lean_alloc_ctor(0, 2, 1);
+lean_ctor_set(x_22, 0, x_20);
+lean_ctor_set(x_22, 1, x_19);
+lean_ctor_set_uint8(x_22, sizeof(void*)*2, x_21);
+return x_22;
 }
 }
 }
@@ -2878,7 +2884,7 @@ if (x_3 == 0)
 lean_object* x_4; lean_object* x_5; lean_object* x_6; uint8_t x_7; 
 x_4 = l_Lean_rootNamespace;
 x_5 = lean_box(0);
-x_6 = l_Lean_Name_replacePrefix___main(x_2, x_4, x_5);
+x_6 = l_Lean_Name_replacePrefix(x_2, x_4, x_5);
 lean_inc(x_1);
 x_7 = l_Lean_Environment_contains(x_1, x_6);
 if (x_7 == 0)
@@ -3872,20 +3878,12 @@ return x_1;
 static lean_object* _init_l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3() {
 _start:
 {
-lean_object* x_1; 
-x_1 = lean_mk_string("unreachable code has been reached");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_ResolveName_resolveNamespaceUsingScope___closed__4() {
-_start:
-{
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__1;
 x_2 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__2;
 x_3 = lean_unsigned_to_nat(114u);
 x_4 = lean_unsigned_to_nat(25u);
-x_5 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
+x_5 = l_Lean_Name_getString_x21___closed__3;
 x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
 return x_6;
 }
@@ -3928,7 +3926,7 @@ default:
 lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 lean_dec(x_2);
 x_10 = lean_box(0);
-x_11 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__4;
+x_11 = l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3;
 x_12 = lean_panic_fn(x_10, x_11);
 return x_12;
 }
@@ -5102,8 +5100,6 @@ l_Lean_ResolveName_resolveNamespaceUsingScope___closed__2 = _init_l_Lean_Resolve
 lean_mark_persistent(l_Lean_ResolveName_resolveNamespaceUsingScope___closed__2);
 l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3 = _init_l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3();
 lean_mark_persistent(l_Lean_ResolveName_resolveNamespaceUsingScope___closed__3);
-l_Lean_ResolveName_resolveNamespaceUsingScope___closed__4 = _init_l_Lean_ResolveName_resolveNamespaceUsingScope___closed__4();
-lean_mark_persistent(l_Lean_ResolveName_resolveNamespaceUsingScope___closed__4);
 l_Lean_resolveNamespace___rarg___lambda__1___closed__1 = _init_l_Lean_resolveNamespace___rarg___lambda__1___closed__1();
 lean_mark_persistent(l_Lean_resolveNamespace___rarg___lambda__1___closed__1);
 l_Lean_resolveGlobalConstNoOverload___rarg___lambda__1___closed__1 = _init_l_Lean_resolveGlobalConstNoOverload___rarg___lambda__1___closed__1();
diff --git a/stage0/stdlib/Lean/Server.c b/stage0/stdlib/Lean/Server.c
index 4d26e2fac5..bd1473b4f4 100644
--- a/stage0/stdlib/Lean/Server.c
+++ b/stage0/stdlib/Lean/Server.c
@@ -43,7 +43,6 @@ lean_object* l_Array_forMAux___main___at_Lean_Server_handleDidChange___spec__1(l
 lean_object* l_Array_forMAux___main___at_Lean_Server_handleDidChange___spec__1___closed__1;
 lean_object* lean_get_stderr(lean_object*);
 lean_object* l_Array_forMAux___main___at_Lean_Server_handleDidChange___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Server_findOpenDocument___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Server_initAndRunServer___closed__2;
 lean_object* l_Lean_Server_parseParams(lean_object*);
 lean_object* l_Lean_Server_handleRequest(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -100,10 +99,12 @@ lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_InitializeParams_hasFromJ
 lean_object* l_IO_FS_Stream_readNotificationAs___at_Lean_Server_initAndRunServer___spec__9___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_take(lean_object*, lean_object*);
 extern lean_object* l_Lean_Parser_Command_exit___elambda__1___closed__1;
+lean_object* l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Server_handleDidOpen(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Lean_Lsp_msgToDiagnostic___closed__1;
 extern lean_object* l_Lean_Lsp_ServerCapabilities_hasToJson___closed__1;
 lean_object* l___private_Lean_Server_1__replaceLspRange(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Server_findOpenDocument___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Server_updateOpenDocuments___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_TextDocumentEdit_hasFromJson___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_Server_writeLspResponse___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -112,6 +113,7 @@ extern lean_object* l_IO_FS_Stream_readRequestAs___closed__7;
 extern lean_object* l_IO_FS_Stream_readRequestAs___closed__3;
 lean_object* lean_array_fset(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_mapMAux___at_Lean_Server_sendDiagnostics___spec__2(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees___rarg(lean_object*, lean_object*);
 lean_object* l_Lean_Server_writeLspNotification___at_Lean_Server_clearDiagnostics___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Json_getObjValAs_x3f___at_Lean_Lsp_TextDocumentPositionParams_hasFromJson___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balRight___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
@@ -126,6 +128,7 @@ lean_object* lean_st_mk_ref(lean_object*, lean_object*);
 lean_object* l_Std_PersistentArray_mapM___at_Lean_Server_sendDiagnostics___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_handleNotification___closed__6;
 lean_object* l_Lean_Server_parseParams___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2___boxed(lean_object*, lean_object*);
 lean_object* lean_stream_of_handle(lean_object*);
 lean_object* l_Lean_Server_Test_runWithInputFile___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_readLspRequestAs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
@@ -136,8 +139,6 @@ lean_object* l_IO_mkRef___at_Lean_Server_initAndRunServer___spec__1(lean_object*
 lean_object* l_Lean_FileMap_ofString(lean_object*);
 lean_object* l_IO_FS_Stream_readRequestAs___at_Lean_Server_initAndRunServer___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balLeft___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_appendTrees___main___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Array_forMAux___main___at_Lean_Server_handleDidChange___spec__1___closed__2;
 lean_object* l_Lean_Server_findOpenDocument___closed__1;
 lean_object* l_Lean_Server_findOpenDocument___boxed(lean_object*, lean_object*, lean_object*);
@@ -151,6 +152,7 @@ lean_object* l_Lean_Lsp_writeLspResponse___at_Lean_Server_initAndRunServer___spe
 lean_object* l_Lean_Json_compress___main(lean_object*);
 lean_object* l_Lean_Lsp_writeLspResponse___at_Lean_Server_handleRequest___spec__3(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Lsp_writeLspResponse___at_Lean_Server_initAndRunServer___spec__6(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* lean_init_search_path(lean_object*, lean_object*);
 extern lean_object* l_Lean_Lsp_InitializeParams_hasFromJson___closed__3;
 lean_object* l_Lean_Server_handleDidClose(lean_object*, lean_object*, lean_object*);
@@ -177,10 +179,8 @@ extern lean_object* l_Lean_Lsp_InitializeParams_hasFromJson___closed__7;
 lean_object* l_Std_PersistentArray_toArray___rarg(lean_object*);
 lean_object* l_Lean_Server_EditableDocument_updateDocument(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_readLspNotificationAs___at_Lean_Server_initAndRunServer___spec__7(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(lean_object*, lean_object*);
 lean_object* l_Lean_Server_parseParams___at_Lean_Server_handleRequest___spec__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_mkLeanServerCapabilities___closed__1;
-lean_object* l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(lean_object*, lean_object*, lean_object*);
 lean_object* lean_get_stdout(lean_object*);
 lean_object* l_Lean_Server_handleRequest___closed__1;
 lean_object* l_Lean_Server_parseParams___at_Lean_Server_handleNotification___spec__1(lean_object*, lean_object*, lean_object*);
@@ -221,6 +221,7 @@ extern lean_object* l_Lean_Lsp_TextDocumentPositionParams_hasFromJson___closed__
 lean_object* l_Lean_Json_getObjVal_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Server_writeLspNotification___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Server_writeLspResponse(lean_object*);
+lean_object* l_Std_RBNode_find___at_Lean_Server_findOpenDocument___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_Lsp_InitializeParams_hasFromJson___closed__6;
 lean_object* lean_nat_to_int(lean_object*);
 extern lean_object* l_Lean_Lsp_DidChangeTextDocumentParams_hasFromJson___closed__1;
@@ -233,7 +234,6 @@ lean_object* l_Lean_Server_EditableDocument_compileDocument(lean_object*, lean_o
 uint8_t lean_string_dec_lt(lean_object*, lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main___at_Lean_Server_findOpenDocument___spec__1___boxed(lean_object*, lean_object*);
 extern lean_object* l_Lean_Lsp_Location_hasFromJson___closed__1;
 lean_object* l_Lean_Server_readLspMessage(lean_object*, lean_object*);
 lean_object* l_Lean_Server_EditableDocument_compileDocument(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
@@ -674,7 +674,7 @@ lean_dec(x_2);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Server_findOpenDocument___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Server_findOpenDocument___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -736,7 +736,7 @@ if (x_6 == 0)
 {
 lean_object* x_7; lean_object* x_8; 
 x_7 = lean_ctor_get(x_5, 0);
-x_8 = l_Std_RBNode_find___main___at_Lean_Server_findOpenDocument___spec__1(x_7, x_1);
+x_8 = l_Std_RBNode_find___at_Lean_Server_findOpenDocument___spec__1(x_7, x_1);
 lean_dec(x_7);
 if (lean_obj_tag(x_8) == 0)
 {
@@ -769,7 +769,7 @@ x_16 = lean_ctor_get(x_5, 1);
 lean_inc(x_16);
 lean_inc(x_15);
 lean_dec(x_5);
-x_17 = l_Std_RBNode_find___main___at_Lean_Server_findOpenDocument___spec__1(x_15, x_1);
+x_17 = l_Std_RBNode_find___at_Lean_Server_findOpenDocument___spec__1(x_15, x_1);
 lean_dec(x_15);
 if (lean_obj_tag(x_17) == 0)
 {
@@ -799,11 +799,11 @@ return x_25;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main___at_Lean_Server_findOpenDocument___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_find___at_Lean_Server_findOpenDocument___spec__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_find___main___at_Lean_Server_findOpenDocument___spec__1(x_1, x_2);
+x_3 = l_Std_RBNode_find___at_Lean_Server_findOpenDocument___spec__1(x_1, x_2);
 lean_dec(x_2);
 lean_dec(x_1);
 return x_3;
@@ -819,2380 +819,2457 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_4; lean_object* x_5; 
-x_4 = 0;
-x_5 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 3, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_4);
-return x_5;
+lean_object* x_4; uint8_t x_5; lean_object* x_6; 
+x_4 = lean_box(0);
+x_5 = 0;
+x_6 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 1, x_2);
+lean_ctor_set(x_6, 2, x_3);
+lean_ctor_set(x_6, 3, x_4);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
+return x_6;
 }
 else
 {
-uint8_t x_6; 
-x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_6 == 0)
-{
 uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_1);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_7 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
-x_8 = lean_ctor_get(x_1, 0);
-x_9 = lean_ctor_get(x_1, 1);
-x_10 = lean_ctor_get(x_1, 2);
-x_11 = lean_ctor_get(x_1, 3);
-x_12 = lean_string_dec_lt(x_2, x_9);
-if (x_12 == 0)
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_1);
+if (x_8 == 0)
 {
-uint8_t x_13; 
-x_13 = lean_string_dec_lt(x_9, x_2);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
+x_9 = lean_ctor_get(x_1, 0);
+x_10 = lean_ctor_get(x_1, 1);
+x_11 = lean_ctor_get(x_1, 2);
+x_12 = lean_ctor_get(x_1, 3);
+x_13 = lean_string_dec_lt(x_2, x_10);
 if (x_13 == 0)
 {
+uint8_t x_14; 
+x_14 = lean_string_dec_lt(x_10, x_2);
+if (x_14 == 0)
+{
+uint8_t x_15; 
+lean_dec(x_11);
 lean_dec(x_10);
-lean_dec(x_9);
+x_15 = 0;
 lean_ctor_set(x_1, 2, x_3);
 lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_15);
 return x_1;
 }
 else
 {
-lean_object* x_14; 
-x_14 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_11, x_2, x_3);
-lean_ctor_set(x_1, 3, x_14);
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_12, x_2, x_3);
+x_17 = 0;
+lean_ctor_set(x_1, 3, x_16);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_17);
 return x_1;
 }
 }
 else
 {
-lean_object* x_15; 
-x_15 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_8, x_2, x_3);
-lean_ctor_set(x_1, 0, x_15);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_9, x_2, x_3);
+x_19 = 0;
+lean_ctor_set(x_1, 0, x_18);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_19);
 return x_1;
 }
 }
 else
 {
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_16 = lean_ctor_get(x_1, 0);
-x_17 = lean_ctor_get(x_1, 1);
-x_18 = lean_ctor_get(x_1, 2);
-x_19 = lean_ctor_get(x_1, 3);
-lean_inc(x_19);
-lean_inc(x_18);
-lean_inc(x_17);
-lean_inc(x_16);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
+x_20 = lean_ctor_get(x_1, 0);
+x_21 = lean_ctor_get(x_1, 1);
+x_22 = lean_ctor_get(x_1, 2);
+x_23 = lean_ctor_get(x_1, 3);
+lean_inc(x_23);
+lean_inc(x_22);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_1);
-x_20 = lean_string_dec_lt(x_2, x_17);
-if (x_20 == 0)
+x_24 = lean_string_dec_lt(x_2, x_21);
+if (x_24 == 0)
 {
-uint8_t x_21; 
-x_21 = lean_string_dec_lt(x_17, x_2);
-if (x_21 == 0)
+uint8_t x_25; 
+x_25 = lean_string_dec_lt(x_21, x_2);
+if (x_25 == 0)
 {
-lean_object* x_22; 
-lean_dec(x_18);
-lean_dec(x_17);
-x_22 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_22, 0, x_16);
-lean_ctor_set(x_22, 1, x_2);
-lean_ctor_set(x_22, 2, x_3);
-lean_ctor_set(x_22, 3, x_19);
-lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_6);
-return x_22;
+uint8_t x_26; lean_object* x_27; 
+lean_dec(x_22);
+lean_dec(x_21);
+x_26 = 0;
+x_27 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_27, 0, x_20);
+lean_ctor_set(x_27, 1, x_2);
+lean_ctor_set(x_27, 2, x_3);
+lean_ctor_set(x_27, 3, x_23);
+lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_23; lean_object* x_24; 
-x_23 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_19, x_2, x_3);
-x_24 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_24, 0, x_16);
-lean_ctor_set(x_24, 1, x_17);
-lean_ctor_set(x_24, 2, x_18);
-lean_ctor_set(x_24, 3, x_23);
-lean_ctor_set_uint8(x_24, sizeof(void*)*4, x_6);
-return x_24;
+lean_object* x_28; uint8_t x_29; lean_object* x_30; 
+x_28 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_23, x_2, x_3);
+x_29 = 0;
+x_30 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_30, 0, x_20);
+lean_ctor_set(x_30, 1, x_21);
+lean_ctor_set(x_30, 2, x_22);
+lean_ctor_set(x_30, 3, x_28);
+lean_ctor_set_uint8(x_30, sizeof(void*)*4, x_29);
+return x_30;
 }
 }
 else
 {
-lean_object* x_25; lean_object* x_26; 
-x_25 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_16, x_2, x_3);
-x_26 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_26, 0, x_25);
-lean_ctor_set(x_26, 1, x_17);
-lean_ctor_set(x_26, 2, x_18);
-lean_ctor_set(x_26, 3, x_19);
-lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_6);
-return x_26;
+lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_31 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_20, x_2, x_3);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_21);
+lean_ctor_set(x_33, 2, x_22);
+lean_ctor_set(x_33, 3, x_23);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 }
 }
 else
 {
-uint8_t x_27; 
-x_27 = !lean_is_exclusive(x_1);
-if (x_27 == 0)
-{
-lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_28 = lean_ctor_get(x_1, 0);
-x_29 = lean_ctor_get(x_1, 1);
-x_30 = lean_ctor_get(x_1, 2);
-x_31 = lean_ctor_get(x_1, 3);
-x_32 = lean_string_dec_lt(x_2, x_29);
-if (x_32 == 0)
-{
-uint8_t x_33; 
-x_33 = lean_string_dec_lt(x_29, x_2);
-if (x_33 == 0)
-{
-lean_dec(x_30);
-lean_dec(x_29);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-return x_1;
-}
-else
-{
 uint8_t x_34; 
-x_34 = l_Std_RBNode_isRed___rarg(x_31);
+x_34 = !lean_is_exclusive(x_1);
 if (x_34 == 0)
 {
-lean_object* x_35; 
-x_35 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_31, x_2, x_3);
-lean_ctor_set(x_1, 3, x_35);
-return x_1;
-}
-else
-{
-lean_object* x_36; lean_object* x_37; 
-x_36 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_31, x_2, x_3);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-if (lean_obj_tag(x_37) == 0)
-{
-lean_object* x_38; 
-x_38 = lean_ctor_get(x_36, 3);
-lean_inc(x_38);
-if (lean_obj_tag(x_38) == 0)
-{
-uint8_t x_39; 
-x_39 = !lean_is_exclusive(x_36);
+lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; 
+x_35 = lean_ctor_get(x_1, 0);
+x_36 = lean_ctor_get(x_1, 1);
+x_37 = lean_ctor_get(x_1, 2);
+x_38 = lean_ctor_get(x_1, 3);
+x_39 = lean_string_dec_lt(x_2, x_36);
 if (x_39 == 0)
 {
-lean_object* x_40; lean_object* x_41; uint8_t x_42; uint8_t x_43; 
-x_40 = lean_ctor_get(x_36, 3);
-lean_dec(x_40);
-x_41 = lean_ctor_get(x_36, 0);
-lean_dec(x_41);
-x_42 = 0;
-lean_ctor_set(x_36, 0, x_38);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_42);
-x_43 = 1;
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_43);
-return x_1;
-}
-else
+uint8_t x_40; 
+x_40 = lean_string_dec_lt(x_36, x_2);
+if (x_40 == 0)
 {
-lean_object* x_44; lean_object* x_45; uint8_t x_46; lean_object* x_47; uint8_t x_48; 
-x_44 = lean_ctor_get(x_36, 1);
-x_45 = lean_ctor_get(x_36, 2);
-lean_inc(x_45);
-lean_inc(x_44);
+uint8_t x_41; 
+lean_dec(x_37);
 lean_dec(x_36);
-x_46 = 0;
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_38);
-lean_ctor_set(x_47, 1, x_44);
-lean_ctor_set(x_47, 2, x_45);
-lean_ctor_set(x_47, 3, x_38);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = 1;
-lean_ctor_set(x_1, 3, x_47);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+x_41 = 1;
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_41);
+return x_1;
+}
+else
+{
+uint8_t x_42; 
+x_42 = l_Std_RBNode_isRed___rarg(x_38);
+if (x_42 == 0)
+{
+lean_object* x_43; uint8_t x_44; 
+x_43 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_38, x_2, x_3);
+x_44 = 1;
+lean_ctor_set(x_1, 3, x_43);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_44);
+return x_1;
+}
+else
+{
+lean_object* x_45; lean_object* x_46; 
+x_45 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_38, x_2, x_3);
+x_46 = lean_ctor_get(x_45, 0);
+lean_inc(x_46);
+if (lean_obj_tag(x_46) == 0)
+{
+lean_object* x_47; 
+x_47 = lean_ctor_get(x_45, 3);
+lean_inc(x_47);
+if (lean_obj_tag(x_47) == 0)
+{
+uint8_t x_48; 
+x_48 = !lean_is_exclusive(x_45);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; uint8_t x_51; uint8_t x_52; 
+x_49 = lean_ctor_get(x_45, 3);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_45, 0);
+lean_dec(x_50);
+x_51 = 0;
+lean_ctor_set(x_45, 0, x_47);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_51);
+x_52 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_52);
+return x_1;
+}
+else
+{
+lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; 
+x_53 = lean_ctor_get(x_45, 1);
+x_54 = lean_ctor_get(x_45, 2);
+lean_inc(x_54);
+lean_inc(x_53);
+lean_dec(x_45);
+x_55 = 0;
+x_56 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_56, 0, x_47);
+lean_ctor_set(x_56, 1, x_53);
+lean_ctor_set(x_56, 2, x_54);
+lean_ctor_set(x_56, 3, x_47);
+lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
+x_57 = 1;
+lean_ctor_set(x_1, 3, x_56);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_57);
 return x_1;
 }
 }
 else
 {
-uint8_t x_49; 
-x_49 = lean_ctor_get_uint8(x_38, sizeof(void*)*4);
-if (x_49 == 0)
+uint8_t x_58; 
+x_58 = lean_ctor_get_uint8(x_47, sizeof(void*)*4);
+if (x_58 == 0)
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_36);
-if (x_50 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_45);
+if (x_59 == 0)
 {
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_36, 1);
-x_52 = lean_ctor_get(x_36, 2);
-x_53 = lean_ctor_get(x_36, 3);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_36, 0);
-lean_dec(x_54);
-x_55 = !lean_is_exclusive(x_38);
-if (x_55 == 0)
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_45, 1);
+x_61 = lean_ctor_get(x_45, 2);
+x_62 = lean_ctor_get(x_45, 3);
+lean_dec(x_62);
+x_63 = lean_ctor_get(x_45, 0);
+lean_dec(x_63);
+x_64 = !lean_is_exclusive(x_47);
+if (x_64 == 0)
 {
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; 
-x_56 = lean_ctor_get(x_38, 0);
-x_57 = lean_ctor_get(x_38, 1);
-x_58 = lean_ctor_get(x_38, 2);
-x_59 = lean_ctor_get(x_38, 3);
-x_60 = 1;
-lean_ctor_set(x_38, 3, x_37);
-lean_ctor_set(x_38, 2, x_30);
-lean_ctor_set(x_38, 1, x_29);
-lean_ctor_set(x_38, 0, x_28);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_60);
-lean_ctor_set(x_36, 3, x_59);
-lean_ctor_set(x_36, 2, x_58);
-lean_ctor_set(x_36, 1, x_57);
-lean_ctor_set(x_36, 0, x_56);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_60);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_38);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; uint8_t x_70; 
+x_65 = lean_ctor_get(x_47, 0);
+x_66 = lean_ctor_get(x_47, 1);
+x_67 = lean_ctor_get(x_47, 2);
+x_68 = lean_ctor_get(x_47, 3);
+x_69 = 1;
+lean_ctor_set(x_47, 3, x_46);
+lean_ctor_set(x_47, 2, x_37);
+lean_ctor_set(x_47, 1, x_36);
+lean_ctor_set(x_47, 0, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_69);
+lean_ctor_set(x_45, 3, x_68);
+lean_ctor_set(x_45, 2, x_67);
+lean_ctor_set(x_45, 1, x_66);
+lean_ctor_set(x_45, 0, x_65);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_69);
+x_70 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_47);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_70);
 return x_1;
 }
 else
 {
-lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; lean_object* x_66; 
-x_61 = lean_ctor_get(x_38, 0);
-x_62 = lean_ctor_get(x_38, 1);
-x_63 = lean_ctor_get(x_38, 2);
-x_64 = lean_ctor_get(x_38, 3);
-lean_inc(x_64);
-lean_inc(x_63);
-lean_inc(x_62);
-lean_inc(x_61);
-lean_dec(x_38);
-x_65 = 1;
-x_66 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_66, 0, x_28);
-lean_ctor_set(x_66, 1, x_29);
-lean_ctor_set(x_66, 2, x_30);
-lean_ctor_set(x_66, 3, x_37);
-lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
-lean_ctor_set(x_36, 3, x_64);
-lean_ctor_set(x_36, 2, x_63);
-lean_ctor_set(x_36, 1, x_62);
-lean_ctor_set(x_36, 0, x_61);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_65);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_52);
-lean_ctor_set(x_1, 1, x_51);
-lean_ctor_set(x_1, 0, x_66);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-}
-else
-{
-lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_67 = lean_ctor_get(x_36, 1);
-x_68 = lean_ctor_get(x_36, 2);
-lean_inc(x_68);
-lean_inc(x_67);
-lean_dec(x_36);
-x_69 = lean_ctor_get(x_38, 0);
-lean_inc(x_69);
-x_70 = lean_ctor_get(x_38, 1);
-lean_inc(x_70);
-x_71 = lean_ctor_get(x_38, 2);
-lean_inc(x_71);
-x_72 = lean_ctor_get(x_38, 3);
+lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; lean_object* x_76; uint8_t x_77; 
+x_71 = lean_ctor_get(x_47, 0);
+x_72 = lean_ctor_get(x_47, 1);
+x_73 = lean_ctor_get(x_47, 2);
+x_74 = lean_ctor_get(x_47, 3);
+lean_inc(x_74);
+lean_inc(x_73);
 lean_inc(x_72);
-if (lean_is_exclusive(x_38)) {
- lean_ctor_release(x_38, 0);
- lean_ctor_release(x_38, 1);
- lean_ctor_release(x_38, 2);
- lean_ctor_release(x_38, 3);
- x_73 = x_38;
-} else {
- lean_dec_ref(x_38);
- x_73 = lean_box(0);
-}
-x_74 = 1;
-if (lean_is_scalar(x_73)) {
- x_75 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_75 = x_73;
-}
-lean_ctor_set(x_75, 0, x_28);
-lean_ctor_set(x_75, 1, x_29);
-lean_ctor_set(x_75, 2, x_30);
-lean_ctor_set(x_75, 3, x_37);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+lean_inc(x_71);
+lean_dec(x_47);
+x_75 = 1;
 x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_69);
-lean_ctor_set(x_76, 1, x_70);
-lean_ctor_set(x_76, 2, x_71);
-lean_ctor_set(x_76, 3, x_72);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_76);
-lean_ctor_set(x_1, 2, x_68);
-lean_ctor_set(x_1, 1, x_67);
-lean_ctor_set(x_1, 0, x_75);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+lean_ctor_set(x_76, 0, x_35);
+lean_ctor_set(x_76, 1, x_36);
+lean_ctor_set(x_76, 2, x_37);
+lean_ctor_set(x_76, 3, x_46);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+lean_ctor_set(x_45, 3, x_74);
+lean_ctor_set(x_45, 2, x_73);
+lean_ctor_set(x_45, 1, x_72);
+lean_ctor_set(x_45, 0, x_71);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_75);
+x_77 = 0;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_61);
+lean_ctor_set(x_1, 1, x_60);
+lean_ctor_set(x_1, 0, x_76);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_77);
 return x_1;
 }
 }
 else
 {
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_36);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; uint8_t x_80; 
-x_78 = lean_ctor_get(x_36, 3);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_36, 0);
-lean_dec(x_79);
-x_80 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_80);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-return x_1;
-}
-else
-{
-lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
-x_81 = lean_ctor_get(x_36, 1);
-x_82 = lean_ctor_get(x_36, 2);
-lean_inc(x_82);
+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; uint8_t x_85; lean_object* x_86; lean_object* x_87; uint8_t x_88; 
+x_78 = lean_ctor_get(x_45, 1);
+x_79 = lean_ctor_get(x_45, 2);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_45);
+x_80 = lean_ctor_get(x_47, 0);
+lean_inc(x_80);
+x_81 = lean_ctor_get(x_47, 1);
 lean_inc(x_81);
-lean_dec(x_36);
-x_83 = 0;
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_37);
-lean_ctor_set(x_84, 1, x_81);
-lean_ctor_set(x_84, 2, x_82);
-lean_ctor_set(x_84, 3, x_38);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-lean_ctor_set(x_1, 3, x_84);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
+x_82 = lean_ctor_get(x_47, 2);
+lean_inc(x_82);
+x_83 = lean_ctor_get(x_47, 3);
+lean_inc(x_83);
+if (lean_is_exclusive(x_47)) {
+ lean_ctor_release(x_47, 0);
+ lean_ctor_release(x_47, 1);
+ lean_ctor_release(x_47, 2);
+ lean_ctor_release(x_47, 3);
+ x_84 = x_47;
+} else {
+ lean_dec_ref(x_47);
+ x_84 = lean_box(0);
+}
+x_85 = 1;
+if (lean_is_scalar(x_84)) {
+ x_86 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_86 = x_84;
+}
+lean_ctor_set(x_86, 0, x_35);
+lean_ctor_set(x_86, 1, x_36);
+lean_ctor_set(x_86, 2, x_37);
+lean_ctor_set(x_86, 3, x_46);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_80);
+lean_ctor_set(x_87, 1, x_81);
+lean_ctor_set(x_87, 2, x_82);
+lean_ctor_set(x_87, 3, x_83);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
+x_88 = 0;
+lean_ctor_set(x_1, 3, x_87);
+lean_ctor_set(x_1, 2, x_79);
+lean_ctor_set(x_1, 1, x_78);
+lean_ctor_set(x_1, 0, x_86);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_88);
 return x_1;
 }
 }
-}
-}
 else
 {
-uint8_t x_85; 
-x_85 = lean_ctor_get_uint8(x_37, sizeof(void*)*4);
-if (x_85 == 0)
+uint8_t x_89; 
+x_89 = !lean_is_exclusive(x_45);
+if (x_89 == 0)
 {
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_36);
-if (x_86 == 0)
-{
-lean_object* x_87; uint8_t x_88; 
-x_87 = lean_ctor_get(x_36, 0);
-lean_dec(x_87);
-x_88 = !lean_is_exclusive(x_37);
-if (x_88 == 0)
-{
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; 
-x_89 = lean_ctor_get(x_37, 0);
-x_90 = lean_ctor_get(x_37, 1);
-x_91 = lean_ctor_get(x_37, 2);
-x_92 = lean_ctor_get(x_37, 3);
+lean_object* x_90; lean_object* x_91; uint8_t x_92; uint8_t x_93; 
+x_90 = lean_ctor_get(x_45, 3);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_45, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_92);
 x_93 = 1;
-lean_ctor_set(x_37, 3, x_89);
-lean_ctor_set(x_37, 2, x_30);
-lean_ctor_set(x_37, 1, x_29);
-lean_ctor_set(x_37, 0, x_28);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_93);
-lean_ctor_set(x_36, 0, x_92);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_93);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_91);
-lean_ctor_set(x_1, 1, x_90);
-lean_ctor_set(x_1, 0, x_37);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_93);
 return x_1;
 }
 else
 {
-lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; lean_object* x_99; 
-x_94 = lean_ctor_get(x_37, 0);
-x_95 = lean_ctor_get(x_37, 1);
-x_96 = lean_ctor_get(x_37, 2);
-x_97 = lean_ctor_get(x_37, 3);
-lean_inc(x_97);
-lean_inc(x_96);
+lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; uint8_t x_98; 
+x_94 = lean_ctor_get(x_45, 1);
+x_95 = lean_ctor_get(x_45, 2);
 lean_inc(x_95);
 lean_inc(x_94);
-lean_dec(x_37);
+lean_dec(x_45);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_46);
+lean_ctor_set(x_97, 1, x_94);
+lean_ctor_set(x_97, 2, x_95);
+lean_ctor_set(x_97, 3, x_47);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
 x_98 = 1;
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_28);
-lean_ctor_set(x_99, 1, x_29);
-lean_ctor_set(x_99, 2, x_30);
-lean_ctor_set(x_99, 3, x_94);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_98);
-lean_ctor_set(x_36, 0, x_97);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_98);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set(x_1, 2, x_96);
-lean_ctor_set(x_1, 1, x_95);
-lean_ctor_set(x_1, 0, x_99);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_97);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_98);
 return x_1;
 }
 }
+}
+}
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; 
-x_100 = lean_ctor_get(x_36, 1);
-x_101 = lean_ctor_get(x_36, 2);
-x_102 = lean_ctor_get(x_36, 3);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_36);
-x_103 = lean_ctor_get(x_37, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_37, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_37, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_37, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_107 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_107 = lean_box(0);
-}
-x_108 = 1;
-if (lean_is_scalar(x_107)) {
- x_109 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_109 = x_107;
-}
-lean_ctor_set(x_109, 0, x_28);
-lean_ctor_set(x_109, 1, x_29);
-lean_ctor_set(x_109, 2, x_30);
-lean_ctor_set(x_109, 3, x_103);
-lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
-x_110 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_100);
-lean_ctor_set(x_110, 2, x_101);
-lean_ctor_set(x_110, 3, x_102);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_108);
-lean_ctor_set(x_1, 3, x_110);
+uint8_t x_99; 
+x_99 = lean_ctor_get_uint8(x_46, sizeof(void*)*4);
+if (x_99 == 0)
+{
+uint8_t x_100; 
+x_100 = !lean_is_exclusive(x_45);
+if (x_100 == 0)
+{
+lean_object* x_101; uint8_t x_102; 
+x_101 = lean_ctor_get(x_45, 0);
+lean_dec(x_101);
+x_102 = !lean_is_exclusive(x_46);
+if (x_102 == 0)
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_103 = lean_ctor_get(x_46, 0);
+x_104 = lean_ctor_get(x_46, 1);
+x_105 = lean_ctor_get(x_46, 2);
+x_106 = lean_ctor_get(x_46, 3);
+x_107 = 1;
+lean_ctor_set(x_46, 3, x_103);
+lean_ctor_set(x_46, 2, x_37);
+lean_ctor_set(x_46, 1, x_36);
+lean_ctor_set(x_46, 0, x_35);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_107);
+lean_ctor_set(x_45, 0, x_106);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 3, x_45);
 lean_ctor_set(x_1, 2, x_105);
 lean_ctor_set(x_1, 1, x_104);
-lean_ctor_set(x_1, 0, x_109);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
-}
 else
 {
-lean_object* x_111; 
-x_111 = lean_ctor_get(x_36, 3);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; uint8_t x_113; lean_object* x_114; uint8_t x_115; 
+x_109 = lean_ctor_get(x_46, 0);
+x_110 = lean_ctor_get(x_46, 1);
+x_111 = lean_ctor_get(x_46, 2);
+x_112 = lean_ctor_get(x_46, 3);
+lean_inc(x_112);
 lean_inc(x_111);
-if (lean_obj_tag(x_111) == 0)
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_36);
-if (x_112 == 0)
-{
-lean_object* x_113; lean_object* x_114; uint8_t x_115; 
-x_113 = lean_ctor_get(x_36, 3);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_36, 0);
-lean_dec(x_114);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_46);
+x_113 = 1;
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_35);
+lean_ctor_set(x_114, 1, x_36);
+lean_ctor_set(x_114, 2, x_37);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_113);
+lean_ctor_set(x_45, 0, x_112);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_113);
 x_115 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_115);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_115);
 return x_1;
 }
+}
 else
 {
-lean_object* x_116; lean_object* x_117; uint8_t x_118; lean_object* x_119; 
-x_116 = lean_ctor_get(x_36, 1);
-x_117 = lean_ctor_get(x_36, 2);
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; uint8_t x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_116 = lean_ctor_get(x_45, 1);
+x_117 = lean_ctor_get(x_45, 2);
+x_118 = lean_ctor_get(x_45, 3);
+lean_inc(x_118);
 lean_inc(x_117);
 lean_inc(x_116);
-lean_dec(x_36);
-x_118 = 0;
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_37);
-lean_ctor_set(x_119, 1, x_116);
-lean_ctor_set(x_119, 2, x_117);
-lean_ctor_set(x_119, 3, x_111);
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_118);
-lean_ctor_set(x_1, 3, x_119);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+lean_dec(x_45);
+x_119 = lean_ctor_get(x_46, 0);
+lean_inc(x_119);
+x_120 = lean_ctor_get(x_46, 1);
+lean_inc(x_120);
+x_121 = lean_ctor_get(x_46, 2);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_46, 3);
+lean_inc(x_122);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_123 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_123 = lean_box(0);
+}
+x_124 = 1;
+if (lean_is_scalar(x_123)) {
+ x_125 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_125 = x_123;
+}
+lean_ctor_set(x_125, 0, x_35);
+lean_ctor_set(x_125, 1, x_36);
+lean_ctor_set(x_125, 2, x_37);
+lean_ctor_set(x_125, 3, x_119);
+lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_124);
+x_126 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_126, 0, x_122);
+lean_ctor_set(x_126, 1, x_116);
+lean_ctor_set(x_126, 2, x_117);
+lean_ctor_set(x_126, 3, x_118);
+lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_124);
+x_127 = 0;
+lean_ctor_set(x_1, 3, x_126);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_125);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_127);
 return x_1;
 }
 }
 else
 {
-uint8_t x_120; 
-x_120 = lean_ctor_get_uint8(x_111, sizeof(void*)*4);
-if (x_120 == 0)
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_45, 3);
+lean_inc(x_128);
+if (lean_obj_tag(x_128) == 0)
 {
-uint8_t x_121; 
-lean_free_object(x_1);
-x_121 = !lean_is_exclusive(x_36);
-if (x_121 == 0)
-{
-lean_object* x_122; lean_object* x_123; uint8_t x_124; 
-x_122 = lean_ctor_get(x_36, 3);
-lean_dec(x_122);
-x_123 = lean_ctor_get(x_36, 0);
-lean_dec(x_123);
-x_124 = !lean_is_exclusive(x_111);
-if (x_124 == 0)
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint8_t x_129; 
-x_125 = lean_ctor_get(x_111, 0);
-x_126 = lean_ctor_get(x_111, 1);
-x_127 = lean_ctor_get(x_111, 2);
-x_128 = lean_ctor_get(x_111, 3);
-lean_inc(x_37);
-lean_ctor_set(x_111, 3, x_37);
-lean_ctor_set(x_111, 2, x_30);
-lean_ctor_set(x_111, 1, x_29);
-lean_ctor_set(x_111, 0, x_28);
-x_129 = !lean_is_exclusive(x_37);
+uint8_t x_129; 
+x_129 = !lean_is_exclusive(x_45);
 if (x_129 == 0)
 {
-lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_130 = lean_ctor_get(x_37, 3);
+lean_object* x_130; lean_object* x_131; uint8_t x_132; uint8_t x_133; 
+x_130 = lean_ctor_get(x_45, 3);
 lean_dec(x_130);
-x_131 = lean_ctor_get(x_37, 2);
+x_131 = lean_ctor_get(x_45, 0);
 lean_dec(x_131);
-x_132 = lean_ctor_get(x_37, 1);
-lean_dec(x_132);
-x_133 = lean_ctor_get(x_37, 0);
-lean_dec(x_133);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-lean_ctor_set(x_37, 3, x_128);
-lean_ctor_set(x_37, 2, x_127);
-lean_ctor_set(x_37, 1, x_126);
-lean_ctor_set(x_37, 0, x_125);
-lean_ctor_set(x_36, 3, x_37);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-else
-{
-lean_object* x_134; 
-lean_dec(x_37);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_85);
-x_134 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_134, 0, x_125);
-lean_ctor_set(x_134, 1, x_126);
-lean_ctor_set(x_134, 2, x_127);
-lean_ctor_set(x_134, 3, x_128);
-lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_134);
-lean_ctor_set(x_36, 0, x_111);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; 
-x_135 = lean_ctor_get(x_111, 0);
-x_136 = lean_ctor_get(x_111, 1);
-x_137 = lean_ctor_get(x_111, 2);
-x_138 = lean_ctor_get(x_111, 3);
-lean_inc(x_138);
-lean_inc(x_137);
-lean_inc(x_136);
-lean_inc(x_135);
-lean_dec(x_111);
-lean_inc(x_37);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_28);
-lean_ctor_set(x_139, 1, x_29);
-lean_ctor_set(x_139, 2, x_30);
-lean_ctor_set(x_139, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_140 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_140 = lean_box(0);
-}
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_141 = x_140;
-}
-lean_ctor_set(x_141, 0, x_135);
-lean_ctor_set(x_141, 1, x_136);
-lean_ctor_set(x_141, 2, x_137);
-lean_ctor_set(x_141, 3, x_138);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_85);
-lean_ctor_set(x_36, 3, x_141);
-lean_ctor_set(x_36, 0, x_139);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_120);
-return x_36;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; 
-x_142 = lean_ctor_get(x_36, 1);
-x_143 = lean_ctor_get(x_36, 2);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_36);
-x_144 = lean_ctor_get(x_111, 0);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_111, 1);
-lean_inc(x_145);
-x_146 = lean_ctor_get(x_111, 2);
-lean_inc(x_146);
-x_147 = lean_ctor_get(x_111, 3);
-lean_inc(x_147);
-if (lean_is_exclusive(x_111)) {
- lean_ctor_release(x_111, 0);
- lean_ctor_release(x_111, 1);
- lean_ctor_release(x_111, 2);
- lean_ctor_release(x_111, 3);
- x_148 = x_111;
-} else {
- lean_dec_ref(x_111);
- x_148 = lean_box(0);
-}
-lean_inc(x_37);
-if (lean_is_scalar(x_148)) {
- x_149 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_149 = x_148;
-}
-lean_ctor_set(x_149, 0, x_28);
-lean_ctor_set(x_149, 1, x_29);
-lean_ctor_set(x_149, 2, x_30);
-lean_ctor_set(x_149, 3, x_37);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_150 = x_37;
-} else {
- lean_dec_ref(x_37);
- x_150 = lean_box(0);
-}
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_85);
-if (lean_is_scalar(x_150)) {
- x_151 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_151 = x_150;
-}
-lean_ctor_set(x_151, 0, x_144);
-lean_ctor_set(x_151, 1, x_145);
-lean_ctor_set(x_151, 2, x_146);
-lean_ctor_set(x_151, 3, x_147);
-lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_85);
-x_152 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_152, 0, x_149);
-lean_ctor_set(x_152, 1, x_142);
-lean_ctor_set(x_152, 2, x_143);
-lean_ctor_set(x_152, 3, x_151);
-lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_120);
-return x_152;
-}
-}
-else
-{
-uint8_t x_153; 
-x_153 = !lean_is_exclusive(x_36);
-if (x_153 == 0)
-{
-lean_object* x_154; lean_object* x_155; uint8_t x_156; 
-x_154 = lean_ctor_get(x_36, 3);
-lean_dec(x_154);
-x_155 = lean_ctor_get(x_36, 0);
-lean_dec(x_155);
-x_156 = !lean_is_exclusive(x_37);
-if (x_156 == 0)
-{
-uint8_t x_157; 
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_120);
-x_157 = 0;
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_157);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
+x_132 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_132);
+x_133 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
 return x_1;
 }
 else
 {
-lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_158 = lean_ctor_get(x_37, 0);
-x_159 = lean_ctor_get(x_37, 1);
-x_160 = lean_ctor_get(x_37, 2);
-x_161 = lean_ctor_get(x_37, 3);
-lean_inc(x_161);
+lean_object* x_134; lean_object* x_135; uint8_t x_136; lean_object* x_137; uint8_t x_138; 
+x_134 = lean_ctor_get(x_45, 1);
+x_135 = lean_ctor_get(x_45, 2);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_dec(x_45);
+x_136 = 0;
+x_137 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_137, 0, x_46);
+lean_ctor_set(x_137, 1, x_134);
+lean_ctor_set(x_137, 2, x_135);
+lean_ctor_set(x_137, 3, x_128);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_136);
+x_138 = 1;
+lean_ctor_set(x_1, 3, x_137);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_138);
+return x_1;
+}
+}
+else
+{
+uint8_t x_139; 
+x_139 = lean_ctor_get_uint8(x_128, sizeof(void*)*4);
+if (x_139 == 0)
+{
+uint8_t x_140; 
+lean_free_object(x_1);
+x_140 = !lean_is_exclusive(x_45);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; 
+x_141 = lean_ctor_get(x_45, 3);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_45, 0);
+lean_dec(x_142);
+x_143 = !lean_is_exclusive(x_128);
+if (x_143 == 0)
+{
+lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; uint8_t x_149; 
+x_144 = lean_ctor_get(x_128, 0);
+x_145 = lean_ctor_get(x_128, 1);
+x_146 = lean_ctor_get(x_128, 2);
+x_147 = lean_ctor_get(x_128, 3);
+x_148 = 1;
+lean_inc(x_46);
+lean_ctor_set(x_128, 3, x_46);
+lean_ctor_set(x_128, 2, x_37);
+lean_ctor_set(x_128, 1, x_36);
+lean_ctor_set(x_128, 0, x_35);
+x_149 = !lean_is_exclusive(x_46);
+if (x_149 == 0)
+{
+lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_150 = lean_ctor_get(x_46, 3);
+lean_dec(x_150);
+x_151 = lean_ctor_get(x_46, 2);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_46, 1);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_46, 0);
+lean_dec(x_153);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+lean_ctor_set(x_46, 3, x_147);
+lean_ctor_set(x_46, 2, x_146);
+lean_ctor_set(x_46, 1, x_145);
+lean_ctor_set(x_46, 0, x_144);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_148);
+x_154 = 0;
+lean_ctor_set(x_45, 3, x_46);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_154);
+return x_45;
+}
+else
+{
+lean_object* x_155; uint8_t x_156; 
+lean_dec(x_46);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_148);
+x_155 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_155, 0, x_144);
+lean_ctor_set(x_155, 1, x_145);
+lean_ctor_set(x_155, 2, x_146);
+lean_ctor_set(x_155, 3, x_147);
+lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_148);
+x_156 = 0;
+lean_ctor_set(x_45, 3, x_155);
+lean_ctor_set(x_45, 0, x_128);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_156);
+return x_45;
+}
+}
+else
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_157 = lean_ctor_get(x_128, 0);
+x_158 = lean_ctor_get(x_128, 1);
+x_159 = lean_ctor_get(x_128, 2);
+x_160 = lean_ctor_get(x_128, 3);
 lean_inc(x_160);
 lean_inc(x_159);
 lean_inc(x_158);
-lean_dec(x_37);
+lean_inc(x_157);
+lean_dec(x_128);
+x_161 = 1;
+lean_inc(x_46);
 x_162 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_162, 0, x_158);
-lean_ctor_set(x_162, 1, x_159);
-lean_ctor_set(x_162, 2, x_160);
-lean_ctor_set(x_162, 3, x_161);
-lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_120);
-x_163 = 0;
-lean_ctor_set(x_36, 0, x_162);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_163);
-lean_ctor_set(x_1, 3, x_36);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
+lean_ctor_set(x_162, 0, x_35);
+lean_ctor_set(x_162, 1, x_36);
+lean_ctor_set(x_162, 2, x_37);
+lean_ctor_set(x_162, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_163 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_163 = lean_box(0);
+}
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+if (lean_is_scalar(x_163)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_164 = x_163;
+}
+lean_ctor_set(x_164, 0, x_157);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_161);
+x_165 = 0;
+lean_ctor_set(x_45, 3, x_164);
+lean_ctor_set(x_45, 0, x_162);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_165);
+return x_45;
 }
 }
 else
 {
-lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; 
-x_164 = lean_ctor_get(x_36, 1);
-x_165 = lean_ctor_get(x_36, 2);
-lean_inc(x_165);
-lean_inc(x_164);
-lean_dec(x_36);
-x_166 = lean_ctor_get(x_37, 0);
-lean_inc(x_166);
-x_167 = lean_ctor_get(x_37, 1);
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_166 = lean_ctor_get(x_45, 1);
+x_167 = lean_ctor_get(x_45, 2);
 lean_inc(x_167);
-x_168 = lean_ctor_get(x_37, 2);
+lean_inc(x_166);
+lean_dec(x_45);
+x_168 = lean_ctor_get(x_128, 0);
 lean_inc(x_168);
-x_169 = lean_ctor_get(x_37, 3);
+x_169 = lean_ctor_get(x_128, 1);
 lean_inc(x_169);
-if (lean_is_exclusive(x_37)) {
- lean_ctor_release(x_37, 0);
- lean_ctor_release(x_37, 1);
- lean_ctor_release(x_37, 2);
- lean_ctor_release(x_37, 3);
- x_170 = x_37;
+x_170 = lean_ctor_get(x_128, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_128, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_128)) {
+ lean_ctor_release(x_128, 0);
+ lean_ctor_release(x_128, 1);
+ lean_ctor_release(x_128, 2);
+ lean_ctor_release(x_128, 3);
+ x_172 = x_128;
 } else {
- lean_dec_ref(x_37);
- x_170 = lean_box(0);
+ lean_dec_ref(x_128);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_170)) {
- x_171 = lean_alloc_ctor(1, 4, 1);
+x_173 = 1;
+lean_inc(x_46);
+if (lean_is_scalar(x_172)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_171 = x_170;
-}
-lean_ctor_set(x_171, 0, x_166);
-lean_ctor_set(x_171, 1, x_167);
-lean_ctor_set(x_171, 2, x_168);
-lean_ctor_set(x_171, 3, x_169);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_120);
-x_172 = 0;
-x_173 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_173, 0, x_171);
-lean_ctor_set(x_173, 1, x_164);
-lean_ctor_set(x_173, 2, x_165);
-lean_ctor_set(x_173, 3, x_111);
-lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
-lean_ctor_set(x_1, 3, x_173);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_120);
-return x_1;
-}
-}
-}
+ x_174 = x_172;
 }
+lean_ctor_set(x_174, 0, x_35);
+lean_ctor_set(x_174, 1, x_36);
+lean_ctor_set(x_174, 2, x_37);
+lean_ctor_set(x_174, 3, x_46);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_175 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_175 = lean_box(0);
 }
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_173);
+if (lean_is_scalar(x_175)) {
+ x_176 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_176 = x_175;
 }
+lean_ctor_set(x_176, 0, x_168);
+lean_ctor_set(x_176, 1, x_169);
+lean_ctor_set(x_176, 2, x_170);
+lean_ctor_set(x_176, 3, x_171);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_173);
+x_177 = 0;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_166);
+lean_ctor_set(x_178, 2, x_167);
+lean_ctor_set(x_178, 3, x_176);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 else
 {
-uint8_t x_174; 
-x_174 = l_Std_RBNode_isRed___rarg(x_28);
-if (x_174 == 0)
-{
-lean_object* x_175; 
-x_175 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_28, x_2, x_3);
-lean_ctor_set(x_1, 0, x_175);
-return x_1;
-}
-else
-{
-lean_object* x_176; lean_object* x_177; 
-x_176 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_28, x_2, x_3);
-x_177 = lean_ctor_get(x_176, 0);
-lean_inc(x_177);
-if (lean_obj_tag(x_177) == 0)
-{
-lean_object* x_178; 
-x_178 = lean_ctor_get(x_176, 3);
-lean_inc(x_178);
-if (lean_obj_tag(x_178) == 0)
-{
 uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_176);
+x_179 = !lean_is_exclusive(x_45);
 if (x_179 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; uint8_t x_183; 
-x_180 = lean_ctor_get(x_176, 3);
+lean_object* x_180; lean_object* x_181; uint8_t x_182; 
+x_180 = lean_ctor_get(x_45, 3);
 lean_dec(x_180);
-x_181 = lean_ctor_get(x_176, 0);
+x_181 = lean_ctor_get(x_45, 0);
 lean_dec(x_181);
-x_182 = 0;
-lean_ctor_set(x_176, 0, x_178);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_182);
-x_183 = 1;
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_183);
+x_182 = !lean_is_exclusive(x_46);
+if (x_182 == 0)
+{
+uint8_t x_183; uint8_t x_184; 
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_139);
+x_183 = 0;
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_183);
+x_184 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_184);
 return x_1;
 }
 else
 {
-lean_object* x_184; lean_object* x_185; uint8_t x_186; lean_object* x_187; uint8_t x_188; 
-x_184 = lean_ctor_get(x_176, 1);
-x_185 = lean_ctor_get(x_176, 2);
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; uint8_t x_191; 
+x_185 = lean_ctor_get(x_46, 0);
+x_186 = lean_ctor_get(x_46, 1);
+x_187 = lean_ctor_get(x_46, 2);
+x_188 = lean_ctor_get(x_46, 3);
+lean_inc(x_188);
+lean_inc(x_187);
+lean_inc(x_186);
 lean_inc(x_185);
-lean_inc(x_184);
-lean_dec(x_176);
-x_186 = 0;
-x_187 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_187, 0, x_178);
-lean_ctor_set(x_187, 1, x_184);
-lean_ctor_set(x_187, 2, x_185);
-lean_ctor_set(x_187, 3, x_178);
-lean_ctor_set_uint8(x_187, sizeof(void*)*4, x_186);
-x_188 = 1;
-lean_ctor_set(x_1, 0, x_187);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_188);
+lean_dec(x_46);
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_185);
+lean_ctor_set(x_189, 1, x_186);
+lean_ctor_set(x_189, 2, x_187);
+lean_ctor_set(x_189, 3, x_188);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_139);
+x_190 = 0;
+lean_ctor_set(x_45, 0, x_189);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_1, 3, x_45);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_191);
 return x_1;
 }
 }
 else
 {
-uint8_t x_189; 
-x_189 = lean_ctor_get_uint8(x_178, sizeof(void*)*4);
-if (x_189 == 0)
-{
-uint8_t x_190; 
-x_190 = !lean_is_exclusive(x_176);
-if (x_190 == 0)
-{
-lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_176, 1);
-x_192 = lean_ctor_get(x_176, 2);
-x_193 = lean_ctor_get(x_176, 3);
-lean_dec(x_193);
-x_194 = lean_ctor_get(x_176, 0);
-lean_dec(x_194);
-x_195 = !lean_is_exclusive(x_178);
-if (x_195 == 0)
-{
-lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; 
-x_196 = lean_ctor_get(x_178, 0);
-x_197 = lean_ctor_get(x_178, 1);
-x_198 = lean_ctor_get(x_178, 2);
-x_199 = lean_ctor_get(x_178, 3);
-x_200 = 1;
-lean_ctor_set(x_178, 3, x_196);
-lean_ctor_set(x_178, 2, x_192);
-lean_ctor_set(x_178, 1, x_191);
-lean_ctor_set(x_178, 0, x_177);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_200);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_199);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_200);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_198);
-lean_ctor_set(x_1, 1, x_197);
-lean_ctor_set(x_1, 0, x_178);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; uint8_t x_200; lean_object* x_201; uint8_t x_202; 
+x_192 = lean_ctor_get(x_45, 1);
+x_193 = lean_ctor_get(x_45, 2);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_45);
+x_194 = lean_ctor_get(x_46, 0);
+lean_inc(x_194);
+x_195 = lean_ctor_get(x_46, 1);
+lean_inc(x_195);
+x_196 = lean_ctor_get(x_46, 2);
+lean_inc(x_196);
+x_197 = lean_ctor_get(x_46, 3);
+lean_inc(x_197);
+if (lean_is_exclusive(x_46)) {
+ lean_ctor_release(x_46, 0);
+ lean_ctor_release(x_46, 1);
+ lean_ctor_release(x_46, 2);
+ lean_ctor_release(x_46, 3);
+ x_198 = x_46;
+} else {
+ lean_dec_ref(x_46);
+ x_198 = lean_box(0);
+}
+if (lean_is_scalar(x_198)) {
+ x_199 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_199 = x_198;
+}
+lean_ctor_set(x_199, 0, x_194);
+lean_ctor_set(x_199, 1, x_195);
+lean_ctor_set(x_199, 2, x_196);
+lean_ctor_set(x_199, 3, x_197);
+lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_139);
+x_200 = 0;
+x_201 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_201, 0, x_199);
+lean_ctor_set(x_201, 1, x_192);
+lean_ctor_set(x_201, 2, x_193);
+lean_ctor_set(x_201, 3, x_128);
+lean_ctor_set_uint8(x_201, sizeof(void*)*4, x_200);
+x_202 = 1;
+lean_ctor_set(x_1, 3, x_201);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_202);
 return x_1;
 }
+}
+}
+}
+}
+}
+}
+}
 else
 {
-lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; lean_object* x_206; 
-x_201 = lean_ctor_get(x_178, 0);
-x_202 = lean_ctor_get(x_178, 1);
-x_203 = lean_ctor_get(x_178, 2);
-x_204 = lean_ctor_get(x_178, 3);
-lean_inc(x_204);
-lean_inc(x_203);
-lean_inc(x_202);
-lean_inc(x_201);
-lean_dec(x_178);
+uint8_t x_203; 
+x_203 = l_Std_RBNode_isRed___rarg(x_35);
+if (x_203 == 0)
+{
+lean_object* x_204; uint8_t x_205; 
+x_204 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_35, x_2, x_3);
 x_205 = 1;
-x_206 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_206, 0, x_177);
-lean_ctor_set(x_206, 1, x_191);
-lean_ctor_set(x_206, 2, x_192);
-lean_ctor_set(x_206, 3, x_201);
-lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_205);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_204);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_205);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_203);
-lean_ctor_set(x_1, 1, x_202);
-lean_ctor_set(x_1, 0, x_206);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+lean_ctor_set(x_1, 0, x_204);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_205);
 return x_1;
 }
-}
 else
 {
-lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; uint8_t x_214; lean_object* x_215; lean_object* x_216; 
-x_207 = lean_ctor_get(x_176, 1);
-x_208 = lean_ctor_get(x_176, 2);
-lean_inc(x_208);
+lean_object* x_206; lean_object* x_207; 
+x_206 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_35, x_2, x_3);
+x_207 = lean_ctor_get(x_206, 0);
 lean_inc(x_207);
-lean_dec(x_176);
-x_209 = lean_ctor_get(x_178, 0);
-lean_inc(x_209);
-x_210 = lean_ctor_get(x_178, 1);
-lean_inc(x_210);
-x_211 = lean_ctor_get(x_178, 2);
-lean_inc(x_211);
-x_212 = lean_ctor_get(x_178, 3);
-lean_inc(x_212);
-if (lean_is_exclusive(x_178)) {
- lean_ctor_release(x_178, 0);
- lean_ctor_release(x_178, 1);
- lean_ctor_release(x_178, 2);
- lean_ctor_release(x_178, 3);
- x_213 = x_178;
-} else {
- lean_dec_ref(x_178);
- x_213 = lean_box(0);
+if (lean_obj_tag(x_207) == 0)
+{
+lean_object* x_208; 
+x_208 = lean_ctor_get(x_206, 3);
+lean_inc(x_208);
+if (lean_obj_tag(x_208) == 0)
+{
+uint8_t x_209; 
+x_209 = !lean_is_exclusive(x_206);
+if (x_209 == 0)
+{
+lean_object* x_210; lean_object* x_211; uint8_t x_212; uint8_t x_213; 
+x_210 = lean_ctor_get(x_206, 3);
+lean_dec(x_210);
+x_211 = lean_ctor_get(x_206, 0);
+lean_dec(x_211);
+x_212 = 0;
+lean_ctor_set(x_206, 0, x_208);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_212);
+x_213 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_213);
+return x_1;
 }
-x_214 = 1;
-if (lean_is_scalar(x_213)) {
- x_215 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_215 = x_213;
-}
-lean_ctor_set(x_215, 0, x_177);
-lean_ctor_set(x_215, 1, x_207);
-lean_ctor_set(x_215, 2, x_208);
-lean_ctor_set(x_215, 3, x_209);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_214);
-x_216 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_216, 0, x_212);
-lean_ctor_set(x_216, 1, x_29);
-lean_ctor_set(x_216, 2, x_30);
-lean_ctor_set(x_216, 3, x_31);
-lean_ctor_set_uint8(x_216, sizeof(void*)*4, x_214);
-lean_ctor_set(x_1, 3, x_216);
-lean_ctor_set(x_1, 2, x_211);
-lean_ctor_set(x_1, 1, x_210);
-lean_ctor_set(x_1, 0, x_215);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
+else
+{
+lean_object* x_214; lean_object* x_215; uint8_t x_216; lean_object* x_217; uint8_t x_218; 
+x_214 = lean_ctor_get(x_206, 1);
+x_215 = lean_ctor_get(x_206, 2);
+lean_inc(x_215);
+lean_inc(x_214);
+lean_dec(x_206);
+x_216 = 0;
+x_217 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_217, 0, x_208);
+lean_ctor_set(x_217, 1, x_214);
+lean_ctor_set(x_217, 2, x_215);
+lean_ctor_set(x_217, 3, x_208);
+lean_ctor_set_uint8(x_217, sizeof(void*)*4, x_216);
+x_218 = 1;
+lean_ctor_set(x_1, 0, x_217);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_218);
 return x_1;
 }
 }
 else
 {
-uint8_t x_217; 
-x_217 = !lean_is_exclusive(x_176);
-if (x_217 == 0)
+uint8_t x_219; 
+x_219 = lean_ctor_get_uint8(x_208, sizeof(void*)*4);
+if (x_219 == 0)
 {
-lean_object* x_218; lean_object* x_219; uint8_t x_220; 
-x_218 = lean_ctor_get(x_176, 3);
-lean_dec(x_218);
-x_219 = lean_ctor_get(x_176, 0);
-lean_dec(x_219);
-x_220 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_220);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-else
+uint8_t x_220; 
+x_220 = !lean_is_exclusive(x_206);
+if (x_220 == 0)
 {
-lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; 
-x_221 = lean_ctor_get(x_176, 1);
-x_222 = lean_ctor_get(x_176, 2);
-lean_inc(x_222);
-lean_inc(x_221);
-lean_dec(x_176);
-x_223 = 0;
-x_224 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_224, 0, x_177);
-lean_ctor_set(x_224, 1, x_221);
-lean_ctor_set(x_224, 2, x_222);
-lean_ctor_set(x_224, 3, x_178);
-lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
-lean_ctor_set(x_1, 0, x_224);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_189);
-return x_1;
-}
-}
-}
-}
-else
-{
-uint8_t x_225; 
-x_225 = lean_ctor_get_uint8(x_177, sizeof(void*)*4);
+lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_206, 1);
+x_222 = lean_ctor_get(x_206, 2);
+x_223 = lean_ctor_get(x_206, 3);
+lean_dec(x_223);
+x_224 = lean_ctor_get(x_206, 0);
+lean_dec(x_224);
+x_225 = !lean_is_exclusive(x_208);
 if (x_225 == 0)
 {
-uint8_t x_226; 
-x_226 = !lean_is_exclusive(x_176);
-if (x_226 == 0)
-{
-lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; uint8_t x_231; 
-x_227 = lean_ctor_get(x_176, 1);
-x_228 = lean_ctor_get(x_176, 2);
-x_229 = lean_ctor_get(x_176, 3);
-x_230 = lean_ctor_get(x_176, 0);
-lean_dec(x_230);
-x_231 = !lean_is_exclusive(x_177);
-if (x_231 == 0)
-{
-uint8_t x_232; 
-x_232 = 1;
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_232);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_232);
-lean_ctor_set(x_1, 3, x_176);
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; uint8_t x_231; 
+x_226 = lean_ctor_get(x_208, 0);
+x_227 = lean_ctor_get(x_208, 1);
+x_228 = lean_ctor_get(x_208, 2);
+x_229 = lean_ctor_get(x_208, 3);
+x_230 = 1;
+lean_ctor_set(x_208, 3, x_226);
+lean_ctor_set(x_208, 2, x_222);
+lean_ctor_set(x_208, 1, x_221);
+lean_ctor_set(x_208, 0, x_207);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_230);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_229);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_230);
+x_231 = 0;
+lean_ctor_set(x_1, 3, x_206);
 lean_ctor_set(x_1, 2, x_228);
 lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_177);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_1, 0, x_208);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_231);
 return x_1;
 }
 else
 {
-lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; 
-x_233 = lean_ctor_get(x_177, 0);
-x_234 = lean_ctor_get(x_177, 1);
-x_235 = lean_ctor_get(x_177, 2);
-x_236 = lean_ctor_get(x_177, 3);
-lean_inc(x_236);
+lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; uint8_t x_236; lean_object* x_237; uint8_t x_238; 
+x_232 = lean_ctor_get(x_208, 0);
+x_233 = lean_ctor_get(x_208, 1);
+x_234 = lean_ctor_get(x_208, 2);
+x_235 = lean_ctor_get(x_208, 3);
 lean_inc(x_235);
 lean_inc(x_234);
 lean_inc(x_233);
-lean_dec(x_177);
-x_237 = 1;
-x_238 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_238, 0, x_233);
-lean_ctor_set(x_238, 1, x_234);
-lean_ctor_set(x_238, 2, x_235);
-lean_ctor_set(x_238, 3, x_236);
-lean_ctor_set_uint8(x_238, sizeof(void*)*4, x_237);
-lean_ctor_set(x_176, 3, x_31);
-lean_ctor_set(x_176, 2, x_30);
-lean_ctor_set(x_176, 1, x_29);
-lean_ctor_set(x_176, 0, x_229);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_237);
-lean_ctor_set(x_1, 3, x_176);
-lean_ctor_set(x_1, 2, x_228);
-lean_ctor_set(x_1, 1, x_227);
-lean_ctor_set(x_1, 0, x_238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_inc(x_232);
+lean_dec(x_208);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_207);
+lean_ctor_set(x_237, 1, x_221);
+lean_ctor_set(x_237, 2, x_222);
+lean_ctor_set(x_237, 3, x_232);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_235);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_236);
+x_238 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_234);
+lean_ctor_set(x_1, 1, x_233);
+lean_ctor_set(x_1, 0, x_237);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_238);
 return x_1;
 }
 }
 else
 {
-lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; uint8_t x_247; lean_object* x_248; lean_object* x_249; 
-x_239 = lean_ctor_get(x_176, 1);
-x_240 = lean_ctor_get(x_176, 2);
-x_241 = lean_ctor_get(x_176, 3);
-lean_inc(x_241);
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; uint8_t x_249; 
+x_239 = lean_ctor_get(x_206, 1);
+x_240 = lean_ctor_get(x_206, 2);
 lean_inc(x_240);
 lean_inc(x_239);
-lean_dec(x_176);
-x_242 = lean_ctor_get(x_177, 0);
+lean_dec(x_206);
+x_241 = lean_ctor_get(x_208, 0);
+lean_inc(x_241);
+x_242 = lean_ctor_get(x_208, 1);
 lean_inc(x_242);
-x_243 = lean_ctor_get(x_177, 1);
+x_243 = lean_ctor_get(x_208, 2);
 lean_inc(x_243);
-x_244 = lean_ctor_get(x_177, 2);
+x_244 = lean_ctor_get(x_208, 3);
 lean_inc(x_244);
-x_245 = lean_ctor_get(x_177, 3);
-lean_inc(x_245);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_246 = x_177;
+if (lean_is_exclusive(x_208)) {
+ lean_ctor_release(x_208, 0);
+ lean_ctor_release(x_208, 1);
+ lean_ctor_release(x_208, 2);
+ lean_ctor_release(x_208, 3);
+ x_245 = x_208;
 } else {
- lean_dec_ref(x_177);
- x_246 = lean_box(0);
+ lean_dec_ref(x_208);
+ x_245 = lean_box(0);
 }
-x_247 = 1;
-if (lean_is_scalar(x_246)) {
- x_248 = lean_alloc_ctor(1, 4, 1);
+x_246 = 1;
+if (lean_is_scalar(x_245)) {
+ x_247 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_248 = x_246;
+ x_247 = x_245;
 }
-lean_ctor_set(x_248, 0, x_242);
-lean_ctor_set(x_248, 1, x_243);
-lean_ctor_set(x_248, 2, x_244);
-lean_ctor_set(x_248, 3, x_245);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_247);
-x_249 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_249, 0, x_241);
-lean_ctor_set(x_249, 1, x_29);
-lean_ctor_set(x_249, 2, x_30);
-lean_ctor_set(x_249, 3, x_31);
-lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_247);
-lean_ctor_set(x_1, 3, x_249);
-lean_ctor_set(x_1, 2, x_240);
-lean_ctor_set(x_1, 1, x_239);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set(x_247, 0, x_207);
+lean_ctor_set(x_247, 1, x_239);
+lean_ctor_set(x_247, 2, x_240);
+lean_ctor_set(x_247, 3, x_241);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+x_248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_248, 0, x_244);
+lean_ctor_set(x_248, 1, x_36);
+lean_ctor_set(x_248, 2, x_37);
+lean_ctor_set(x_248, 3, x_38);
+lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
+x_249 = 0;
+lean_ctor_set(x_1, 3, x_248);
+lean_ctor_set(x_1, 2, x_243);
+lean_ctor_set(x_1, 1, x_242);
+lean_ctor_set(x_1, 0, x_247);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_249);
 return x_1;
 }
 }
 else
 {
-lean_object* x_250; 
-x_250 = lean_ctor_get(x_176, 3);
-lean_inc(x_250);
-if (lean_obj_tag(x_250) == 0)
+uint8_t x_250; 
+x_250 = !lean_is_exclusive(x_206);
+if (x_250 == 0)
 {
-uint8_t x_251; 
-x_251 = !lean_is_exclusive(x_176);
-if (x_251 == 0)
-{
-lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_252 = lean_ctor_get(x_176, 3);
+lean_object* x_251; lean_object* x_252; uint8_t x_253; uint8_t x_254; 
+x_251 = lean_ctor_get(x_206, 3);
+lean_dec(x_251);
+x_252 = lean_ctor_get(x_206, 0);
 lean_dec(x_252);
-x_253 = lean_ctor_get(x_176, 0);
-lean_dec(x_253);
-x_254 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_254);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+x_253 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_253);
+x_254 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_254);
 return x_1;
 }
 else
 {
-lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; 
-x_255 = lean_ctor_get(x_176, 1);
-x_256 = lean_ctor_get(x_176, 2);
+lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; uint8_t x_259; 
+x_255 = lean_ctor_get(x_206, 1);
+x_256 = lean_ctor_get(x_206, 2);
 lean_inc(x_256);
 lean_inc(x_255);
-lean_dec(x_176);
+lean_dec(x_206);
 x_257 = 0;
 x_258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_258, 0, x_177);
+lean_ctor_set(x_258, 0, x_207);
 lean_ctor_set(x_258, 1, x_255);
 lean_ctor_set(x_258, 2, x_256);
-lean_ctor_set(x_258, 3, x_250);
+lean_ctor_set(x_258, 3, x_208);
 lean_ctor_set_uint8(x_258, sizeof(void*)*4, x_257);
+x_259 = 1;
 lean_ctor_set(x_1, 0, x_258);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+return x_1;
+}
+}
+}
+}
+else
+{
+uint8_t x_260; 
+x_260 = lean_ctor_get_uint8(x_207, sizeof(void*)*4);
+if (x_260 == 0)
+{
+uint8_t x_261; 
+x_261 = !lean_is_exclusive(x_206);
+if (x_261 == 0)
+{
+lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_206, 1);
+x_263 = lean_ctor_get(x_206, 2);
+x_264 = lean_ctor_get(x_206, 3);
+x_265 = lean_ctor_get(x_206, 0);
+lean_dec(x_265);
+x_266 = !lean_is_exclusive(x_207);
+if (x_266 == 0)
+{
+uint8_t x_267; uint8_t x_268; 
+x_267 = 1;
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_267);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_267);
+x_268 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_207);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_268);
+return x_1;
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; uint8_t x_275; 
+x_269 = lean_ctor_get(x_207, 0);
+x_270 = lean_ctor_get(x_207, 1);
+x_271 = lean_ctor_get(x_207, 2);
+x_272 = lean_ctor_get(x_207, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_207);
+x_273 = 1;
+x_274 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_274, 0, x_269);
+lean_ctor_set(x_274, 1, x_270);
+lean_ctor_set(x_274, 2, x_271);
+lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
+lean_ctor_set(x_206, 3, x_38);
+lean_ctor_set(x_206, 2, x_37);
+lean_ctor_set(x_206, 1, x_36);
+lean_ctor_set(x_206, 0, x_264);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_273);
+x_275 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_263);
+lean_ctor_set(x_1, 1, x_262);
+lean_ctor_set(x_1, 0, x_274);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
 return x_1;
 }
 }
 else
 {
-uint8_t x_259; 
-x_259 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
-if (x_259 == 0)
-{
-uint8_t x_260; 
-lean_free_object(x_1);
-x_260 = !lean_is_exclusive(x_176);
-if (x_260 == 0)
-{
-lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; uint8_t x_265; 
-x_261 = lean_ctor_get(x_176, 1);
-x_262 = lean_ctor_get(x_176, 2);
-x_263 = lean_ctor_get(x_176, 3);
-lean_dec(x_263);
-x_264 = lean_ctor_get(x_176, 0);
-lean_dec(x_264);
-x_265 = !lean_is_exclusive(x_250);
-if (x_265 == 0)
-{
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; uint8_t x_270; 
-x_266 = lean_ctor_get(x_250, 0);
-x_267 = lean_ctor_get(x_250, 1);
-x_268 = lean_ctor_get(x_250, 2);
-x_269 = lean_ctor_get(x_250, 3);
-lean_inc(x_177);
-lean_ctor_set(x_250, 3, x_266);
-lean_ctor_set(x_250, 2, x_262);
-lean_ctor_set(x_250, 1, x_261);
-lean_ctor_set(x_250, 0, x_177);
-x_270 = !lean_is_exclusive(x_177);
-if (x_270 == 0)
-{
-lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; 
-x_271 = lean_ctor_get(x_177, 3);
-lean_dec(x_271);
-x_272 = lean_ctor_get(x_177, 2);
-lean_dec(x_272);
-x_273 = lean_ctor_get(x_177, 1);
-lean_dec(x_273);
-x_274 = lean_ctor_get(x_177, 0);
-lean_dec(x_274);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-lean_ctor_set(x_177, 3, x_31);
-lean_ctor_set(x_177, 2, x_30);
-lean_ctor_set(x_177, 1, x_29);
-lean_ctor_set(x_177, 0, x_269);
-lean_ctor_set(x_176, 3, x_177);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-else
-{
-lean_object* x_275; 
-lean_dec(x_177);
-lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_225);
-x_275 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_275, 0, x_269);
-lean_ctor_set(x_275, 1, x_29);
-lean_ctor_set(x_275, 2, x_30);
-lean_ctor_set(x_275, 3, x_31);
-lean_ctor_set_uint8(x_275, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_275);
-lean_ctor_set(x_176, 2, x_268);
-lean_ctor_set(x_176, 1, x_267);
-lean_ctor_set(x_176, 0, x_250);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
-}
-}
-else
-{
-lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; 
-x_276 = lean_ctor_get(x_250, 0);
-x_277 = lean_ctor_get(x_250, 1);
-x_278 = lean_ctor_get(x_250, 2);
-x_279 = lean_ctor_get(x_250, 3);
-lean_inc(x_279);
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; uint8_t x_284; lean_object* x_285; lean_object* x_286; uint8_t x_287; 
+x_276 = lean_ctor_get(x_206, 1);
+x_277 = lean_ctor_get(x_206, 2);
+x_278 = lean_ctor_get(x_206, 3);
 lean_inc(x_278);
 lean_inc(x_277);
 lean_inc(x_276);
-lean_dec(x_250);
-lean_inc(x_177);
-x_280 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_280, 0, x_177);
-lean_ctor_set(x_280, 1, x_261);
-lean_ctor_set(x_280, 2, x_262);
-lean_ctor_set(x_280, 3, x_276);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_281 = x_177;
+lean_dec(x_206);
+x_279 = lean_ctor_get(x_207, 0);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_207, 1);
+lean_inc(x_280);
+x_281 = lean_ctor_get(x_207, 2);
+lean_inc(x_281);
+x_282 = lean_ctor_get(x_207, 3);
+lean_inc(x_282);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_283 = x_207;
 } else {
- lean_dec_ref(x_177);
- x_281 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_283 = lean_box(0);
 }
-lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_281)) {
- x_282 = lean_alloc_ctor(1, 4, 1);
+x_284 = 1;
+if (lean_is_scalar(x_283)) {
+ x_285 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_282 = x_281;
+ x_285 = x_283;
 }
-lean_ctor_set(x_282, 0, x_279);
-lean_ctor_set(x_282, 1, x_29);
-lean_ctor_set(x_282, 2, x_30);
-lean_ctor_set(x_282, 3, x_31);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_225);
-lean_ctor_set(x_176, 3, x_282);
-lean_ctor_set(x_176, 2, x_278);
-lean_ctor_set(x_176, 1, x_277);
-lean_ctor_set(x_176, 0, x_280);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_259);
-return x_176;
+lean_ctor_set(x_285, 0, x_279);
+lean_ctor_set(x_285, 1, x_280);
+lean_ctor_set(x_285, 2, x_281);
+lean_ctor_set(x_285, 3, x_282);
+lean_ctor_set_uint8(x_285, sizeof(void*)*4, x_284);
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_278);
+lean_ctor_set(x_286, 1, x_36);
+lean_ctor_set(x_286, 2, x_37);
+lean_ctor_set(x_286, 3, x_38);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_284);
+x_287 = 0;
+lean_ctor_set(x_1, 3, x_286);
+lean_ctor_set(x_1, 2, x_277);
+lean_ctor_set(x_1, 1, x_276);
+lean_ctor_set(x_1, 0, x_285);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_287);
+return x_1;
 }
 }
 else
 {
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; 
-x_283 = lean_ctor_get(x_176, 1);
-x_284 = lean_ctor_get(x_176, 2);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_176);
-x_285 = lean_ctor_get(x_250, 0);
-lean_inc(x_285);
-x_286 = lean_ctor_get(x_250, 1);
-lean_inc(x_286);
-x_287 = lean_ctor_get(x_250, 2);
-lean_inc(x_287);
-x_288 = lean_ctor_get(x_250, 3);
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_206, 3);
 lean_inc(x_288);
-if (lean_is_exclusive(x_250)) {
- lean_ctor_release(x_250, 0);
- lean_ctor_release(x_250, 1);
- lean_ctor_release(x_250, 2);
- lean_ctor_release(x_250, 3);
- x_289 = x_250;
-} else {
- lean_dec_ref(x_250);
- x_289 = lean_box(0);
-}
-lean_inc(x_177);
-if (lean_is_scalar(x_289)) {
- x_290 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_290 = x_289;
-}
-lean_ctor_set(x_290, 0, x_177);
-lean_ctor_set(x_290, 1, x_283);
-lean_ctor_set(x_290, 2, x_284);
-lean_ctor_set(x_290, 3, x_285);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_291 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_291 = lean_box(0);
-}
-lean_ctor_set_uint8(x_290, sizeof(void*)*4, x_225);
-if (lean_is_scalar(x_291)) {
- x_292 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_292 = x_291;
-}
-lean_ctor_set(x_292, 0, x_288);
-lean_ctor_set(x_292, 1, x_29);
-lean_ctor_set(x_292, 2, x_30);
-lean_ctor_set(x_292, 3, x_31);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_225);
-x_293 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_293, 0, x_290);
-lean_ctor_set(x_293, 1, x_286);
-lean_ctor_set(x_293, 2, x_287);
-lean_ctor_set(x_293, 3, x_292);
-lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_259);
-return x_293;
-}
-}
-else
+if (lean_obj_tag(x_288) == 0)
 {
-uint8_t x_294; 
-x_294 = !lean_is_exclusive(x_176);
-if (x_294 == 0)
+uint8_t x_289; 
+x_289 = !lean_is_exclusive(x_206);
+if (x_289 == 0)
 {
-lean_object* x_295; lean_object* x_296; uint8_t x_297; 
-x_295 = lean_ctor_get(x_176, 3);
-lean_dec(x_295);
-x_296 = lean_ctor_get(x_176, 0);
-lean_dec(x_296);
-x_297 = !lean_is_exclusive(x_177);
-if (x_297 == 0)
-{
-uint8_t x_298; 
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_259);
-x_298 = 0;
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_290; lean_object* x_291; uint8_t x_292; uint8_t x_293; 
+x_290 = lean_ctor_get(x_206, 3);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_206, 0);
+lean_dec(x_291);
+x_292 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_292);
+x_293 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_293);
 return x_1;
 }
 else
 {
-lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_299 = lean_ctor_get(x_177, 0);
-x_300 = lean_ctor_get(x_177, 1);
-x_301 = lean_ctor_get(x_177, 2);
-x_302 = lean_ctor_get(x_177, 3);
-lean_inc(x_302);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_inc(x_299);
-lean_dec(x_177);
-x_303 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_303, 0, x_299);
-lean_ctor_set(x_303, 1, x_300);
-lean_ctor_set(x_303, 2, x_301);
-lean_ctor_set(x_303, 3, x_302);
-lean_ctor_set_uint8(x_303, sizeof(void*)*4, x_259);
-x_304 = 0;
-lean_ctor_set(x_176, 0, x_303);
-lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_304);
-lean_ctor_set(x_1, 0, x_176);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
+lean_object* x_294; lean_object* x_295; uint8_t x_296; lean_object* x_297; uint8_t x_298; 
+x_294 = lean_ctor_get(x_206, 1);
+x_295 = lean_ctor_get(x_206, 2);
+lean_inc(x_295);
+lean_inc(x_294);
+lean_dec(x_206);
+x_296 = 0;
+x_297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_297, 0, x_207);
+lean_ctor_set(x_297, 1, x_294);
+lean_ctor_set(x_297, 2, x_295);
+lean_ctor_set(x_297, 3, x_288);
+lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_296);
+x_298 = 1;
+lean_ctor_set(x_1, 0, x_297);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
 return x_1;
 }
 }
 else
 {
-lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; uint8_t x_313; lean_object* x_314; 
-x_305 = lean_ctor_get(x_176, 1);
-x_306 = lean_ctor_get(x_176, 2);
-lean_inc(x_306);
-lean_inc(x_305);
-lean_dec(x_176);
-x_307 = lean_ctor_get(x_177, 0);
-lean_inc(x_307);
-x_308 = lean_ctor_get(x_177, 1);
-lean_inc(x_308);
-x_309 = lean_ctor_get(x_177, 2);
-lean_inc(x_309);
-x_310 = lean_ctor_get(x_177, 3);
-lean_inc(x_310);
-if (lean_is_exclusive(x_177)) {
- lean_ctor_release(x_177, 0);
- lean_ctor_release(x_177, 1);
- lean_ctor_release(x_177, 2);
- lean_ctor_release(x_177, 3);
- x_311 = x_177;
-} else {
- lean_dec_ref(x_177);
- x_311 = lean_box(0);
-}
-if (lean_is_scalar(x_311)) {
- x_312 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_312 = x_311;
-}
-lean_ctor_set(x_312, 0, x_307);
-lean_ctor_set(x_312, 1, x_308);
-lean_ctor_set(x_312, 2, x_309);
-lean_ctor_set(x_312, 3, x_310);
-lean_ctor_set_uint8(x_312, sizeof(void*)*4, x_259);
-x_313 = 0;
-x_314 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_314, 0, x_312);
-lean_ctor_set(x_314, 1, x_305);
-lean_ctor_set(x_314, 2, x_306);
-lean_ctor_set(x_314, 3, x_250);
-lean_ctor_set_uint8(x_314, sizeof(void*)*4, x_313);
-lean_ctor_set(x_1, 0, x_314);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_259);
-return x_1;
-}
-}
-}
-}
-}
+uint8_t x_299; 
+x_299 = lean_ctor_get_uint8(x_288, sizeof(void*)*4);
+if (x_299 == 0)
+{
+uint8_t x_300; 
+lean_free_object(x_1);
+x_300 = !lean_is_exclusive(x_206);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_206, 1);
+x_302 = lean_ctor_get(x_206, 2);
+x_303 = lean_ctor_get(x_206, 3);
+lean_dec(x_303);
+x_304 = lean_ctor_get(x_206, 0);
+lean_dec(x_304);
+x_305 = !lean_is_exclusive(x_288);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; uint8_t x_310; uint8_t x_311; 
+x_306 = lean_ctor_get(x_288, 0);
+x_307 = lean_ctor_get(x_288, 1);
+x_308 = lean_ctor_get(x_288, 2);
+x_309 = lean_ctor_get(x_288, 3);
+x_310 = 1;
+lean_inc(x_207);
+lean_ctor_set(x_288, 3, x_306);
+lean_ctor_set(x_288, 2, x_302);
+lean_ctor_set(x_288, 1, x_301);
+lean_ctor_set(x_288, 0, x_207);
+x_311 = !lean_is_exclusive(x_207);
+if (x_311 == 0)
+{
+lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; 
+x_312 = lean_ctor_get(x_207, 3);
+lean_dec(x_312);
+x_313 = lean_ctor_get(x_207, 2);
+lean_dec(x_313);
+x_314 = lean_ctor_get(x_207, 1);
+lean_dec(x_314);
+x_315 = lean_ctor_get(x_207, 0);
+lean_dec(x_315);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+lean_ctor_set(x_207, 3, x_38);
+lean_ctor_set(x_207, 2, x_37);
+lean_ctor_set(x_207, 1, x_36);
+lean_ctor_set(x_207, 0, x_309);
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_310);
+x_316 = 0;
+lean_ctor_set(x_206, 3, x_207);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_316);
+return x_206;
 }
+else
+{
+lean_object* x_317; uint8_t x_318; 
+lean_dec(x_207);
+lean_ctor_set_uint8(x_288, sizeof(void*)*4, x_310);
+x_317 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_317, 0, x_309);
+lean_ctor_set(x_317, 1, x_36);
+lean_ctor_set(x_317, 2, x_37);
+lean_ctor_set(x_317, 3, x_38);
+lean_ctor_set_uint8(x_317, sizeof(void*)*4, x_310);
+x_318 = 0;
+lean_ctor_set(x_206, 3, x_317);
+lean_ctor_set(x_206, 2, x_308);
+lean_ctor_set(x_206, 1, x_307);
+lean_ctor_set(x_206, 0, x_288);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_318);
+return x_206;
 }
 }
 else
 {
-lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; uint8_t x_319; 
-x_315 = lean_ctor_get(x_1, 0);
-x_316 = lean_ctor_get(x_1, 1);
-x_317 = lean_ctor_get(x_1, 2);
-x_318 = lean_ctor_get(x_1, 3);
-lean_inc(x_318);
-lean_inc(x_317);
-lean_inc(x_316);
-lean_inc(x_315);
-lean_dec(x_1);
-x_319 = lean_string_dec_lt(x_2, x_316);
-if (x_319 == 0)
-{
-uint8_t x_320; 
-x_320 = lean_string_dec_lt(x_316, x_2);
-if (x_320 == 0)
-{
-lean_object* x_321; 
-lean_dec(x_317);
-lean_dec(x_316);
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_315);
-lean_ctor_set(x_321, 1, x_2);
-lean_ctor_set(x_321, 2, x_3);
-lean_ctor_set(x_321, 3, x_318);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_6);
-return x_321;
-}
-else
-{
-uint8_t x_322; 
-x_322 = l_Std_RBNode_isRed___rarg(x_318);
-if (x_322 == 0)
-{
-lean_object* x_323; lean_object* x_324; 
-x_323 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_318, x_2, x_3);
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
+x_319 = lean_ctor_get(x_288, 0);
+x_320 = lean_ctor_get(x_288, 1);
+x_321 = lean_ctor_get(x_288, 2);
+x_322 = lean_ctor_get(x_288, 3);
+lean_inc(x_322);
+lean_inc(x_321);
+lean_inc(x_320);
+lean_inc(x_319);
+lean_dec(x_288);
+x_323 = 1;
+lean_inc(x_207);
 x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_315);
-lean_ctor_set(x_324, 1, x_316);
-lean_ctor_set(x_324, 2, x_317);
-lean_ctor_set(x_324, 3, x_323);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_6);
-return x_324;
+lean_ctor_set(x_324, 0, x_207);
+lean_ctor_set(x_324, 1, x_301);
+lean_ctor_set(x_324, 2, x_302);
+lean_ctor_set(x_324, 3, x_319);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_325 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_325 = lean_box(0);
+}
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+if (lean_is_scalar(x_325)) {
+ x_326 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_326 = x_325;
+}
+lean_ctor_set(x_326, 0, x_322);
+lean_ctor_set(x_326, 1, x_36);
+lean_ctor_set(x_326, 2, x_37);
+lean_ctor_set(x_326, 3, x_38);
+lean_ctor_set_uint8(x_326, sizeof(void*)*4, x_323);
+x_327 = 0;
+lean_ctor_set(x_206, 3, x_326);
+lean_ctor_set(x_206, 2, x_321);
+lean_ctor_set(x_206, 1, x_320);
+lean_ctor_set(x_206, 0, x_324);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_327);
+return x_206;
+}
 }
 else
 {
-lean_object* x_325; lean_object* x_326; 
-x_325 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_318, x_2, x_3);
-x_326 = lean_ctor_get(x_325, 0);
-lean_inc(x_326);
-if (lean_obj_tag(x_326) == 0)
-{
-lean_object* x_327; 
-x_327 = lean_ctor_get(x_325, 3);
-lean_inc(x_327);
-if (lean_obj_tag(x_327) == 0)
-{
-lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; lean_object* x_332; uint8_t x_333; lean_object* x_334; 
-x_328 = lean_ctor_get(x_325, 1);
-lean_inc(x_328);
-x_329 = lean_ctor_get(x_325, 2);
+lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; uint8_t x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; uint8_t x_339; lean_object* x_340; 
+x_328 = lean_ctor_get(x_206, 1);
+x_329 = lean_ctor_get(x_206, 2);
 lean_inc(x_329);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_330 = x_325;
+lean_inc(x_328);
+lean_dec(x_206);
+x_330 = lean_ctor_get(x_288, 0);
+lean_inc(x_330);
+x_331 = lean_ctor_get(x_288, 1);
+lean_inc(x_331);
+x_332 = lean_ctor_get(x_288, 2);
+lean_inc(x_332);
+x_333 = lean_ctor_get(x_288, 3);
+lean_inc(x_333);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ lean_ctor_release(x_288, 2);
+ lean_ctor_release(x_288, 3);
+ x_334 = x_288;
 } else {
- lean_dec_ref(x_325);
- x_330 = lean_box(0);
+ lean_dec_ref(x_288);
+ x_334 = lean_box(0);
 }
-x_331 = 0;
-if (lean_is_scalar(x_330)) {
- x_332 = lean_alloc_ctor(1, 4, 1);
+x_335 = 1;
+lean_inc(x_207);
+if (lean_is_scalar(x_334)) {
+ x_336 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_332 = x_330;
+ x_336 = x_334;
+}
+lean_ctor_set(x_336, 0, x_207);
+lean_ctor_set(x_336, 1, x_328);
+lean_ctor_set(x_336, 2, x_329);
+lean_ctor_set(x_336, 3, x_330);
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_337 = x_207;
+} else {
+ lean_dec_ref(x_207);
+ x_337 = lean_box(0);
+}
+lean_ctor_set_uint8(x_336, sizeof(void*)*4, x_335);
+if (lean_is_scalar(x_337)) {
+ x_338 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_338 = x_337;
+}
+lean_ctor_set(x_338, 0, x_333);
+lean_ctor_set(x_338, 1, x_36);
+lean_ctor_set(x_338, 2, x_37);
+lean_ctor_set(x_338, 3, x_38);
+lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_335);
+x_339 = 0;
+x_340 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_340, 0, x_336);
+lean_ctor_set(x_340, 1, x_331);
+lean_ctor_set(x_340, 2, x_332);
+lean_ctor_set(x_340, 3, x_338);
+lean_ctor_set_uint8(x_340, sizeof(void*)*4, x_339);
+return x_340;
 }
-lean_ctor_set(x_332, 0, x_327);
-lean_ctor_set(x_332, 1, x_328);
-lean_ctor_set(x_332, 2, x_329);
-lean_ctor_set(x_332, 3, x_327);
-lean_ctor_set_uint8(x_332, sizeof(void*)*4, x_331);
-x_333 = 1;
-x_334 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_334, 0, x_315);
-lean_ctor_set(x_334, 1, x_316);
-lean_ctor_set(x_334, 2, x_317);
-lean_ctor_set(x_334, 3, x_332);
-lean_ctor_set_uint8(x_334, sizeof(void*)*4, x_333);
-return x_334;
 }
 else
 {
-uint8_t x_335; 
-x_335 = lean_ctor_get_uint8(x_327, sizeof(void*)*4);
-if (x_335 == 0)
+uint8_t x_341; 
+x_341 = !lean_is_exclusive(x_206);
+if (x_341 == 0)
 {
-lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; 
-x_336 = lean_ctor_get(x_325, 1);
-lean_inc(x_336);
-x_337 = lean_ctor_get(x_325, 2);
-lean_inc(x_337);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_338 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_338 = lean_box(0);
-}
-x_339 = lean_ctor_get(x_327, 0);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_327, 1);
-lean_inc(x_340);
-x_341 = lean_ctor_get(x_327, 2);
-lean_inc(x_341);
-x_342 = lean_ctor_get(x_327, 3);
-lean_inc(x_342);
-if (lean_is_exclusive(x_327)) {
- lean_ctor_release(x_327, 0);
- lean_ctor_release(x_327, 1);
- lean_ctor_release(x_327, 2);
- lean_ctor_release(x_327, 3);
- x_343 = x_327;
-} else {
- lean_dec_ref(x_327);
- x_343 = lean_box(0);
-}
-x_344 = 1;
-if (lean_is_scalar(x_343)) {
- x_345 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_345 = x_343;
-}
-lean_ctor_set(x_345, 0, x_315);
-lean_ctor_set(x_345, 1, x_316);
-lean_ctor_set(x_345, 2, x_317);
-lean_ctor_set(x_345, 3, x_326);
-lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_338)) {
- x_346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_346 = x_338;
-}
-lean_ctor_set(x_346, 0, x_339);
-lean_ctor_set(x_346, 1, x_340);
-lean_ctor_set(x_346, 2, x_341);
-lean_ctor_set(x_346, 3, x_342);
-lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_344);
-x_347 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_347, 0, x_345);
-lean_ctor_set(x_347, 1, x_336);
-lean_ctor_set(x_347, 2, x_337);
-lean_ctor_set(x_347, 3, x_346);
-lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_335);
-return x_347;
+lean_object* x_342; lean_object* x_343; uint8_t x_344; 
+x_342 = lean_ctor_get(x_206, 3);
+lean_dec(x_342);
+x_343 = lean_ctor_get(x_206, 0);
+lean_dec(x_343);
+x_344 = !lean_is_exclusive(x_207);
+if (x_344 == 0)
+{
+uint8_t x_345; uint8_t x_346; 
+lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_299);
+x_345 = 0;
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_345);
+x_346 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_346);
+return x_1;
 }
 else
 {
-lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; lean_object* x_352; lean_object* x_353; 
-x_348 = lean_ctor_get(x_325, 1);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_325, 2);
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; uint8_t x_352; uint8_t x_353; 
+x_347 = lean_ctor_get(x_207, 0);
+x_348 = lean_ctor_get(x_207, 1);
+x_349 = lean_ctor_get(x_207, 2);
+x_350 = lean_ctor_get(x_207, 3);
+lean_inc(x_350);
 lean_inc(x_349);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_350 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_350 = lean_box(0);
-}
-x_351 = 0;
-if (lean_is_scalar(x_350)) {
- x_352 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_352 = x_350;
-}
-lean_ctor_set(x_352, 0, x_326);
-lean_ctor_set(x_352, 1, x_348);
-lean_ctor_set(x_352, 2, x_349);
-lean_ctor_set(x_352, 3, x_327);
-lean_ctor_set_uint8(x_352, sizeof(void*)*4, x_351);
-x_353 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_353, 0, x_315);
-lean_ctor_set(x_353, 1, x_316);
-lean_ctor_set(x_353, 2, x_317);
-lean_ctor_set(x_353, 3, x_352);
-lean_ctor_set_uint8(x_353, sizeof(void*)*4, x_335);
-return x_353;
-}
+lean_inc(x_348);
+lean_inc(x_347);
+lean_dec(x_207);
+x_351 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_351, 0, x_347);
+lean_ctor_set(x_351, 1, x_348);
+lean_ctor_set(x_351, 2, x_349);
+lean_ctor_set(x_351, 3, x_350);
+lean_ctor_set_uint8(x_351, sizeof(void*)*4, x_299);
+x_352 = 0;
+lean_ctor_set(x_206, 0, x_351);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_1, 0, x_206);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_353);
+return x_1;
 }
 }
 else
 {
-uint8_t x_354; 
-x_354 = lean_ctor_get_uint8(x_326, sizeof(void*)*4);
-if (x_354 == 0)
-{
-lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; uint8_t x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; 
-x_355 = lean_ctor_get(x_325, 1);
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; uint8_t x_362; lean_object* x_363; uint8_t x_364; 
+x_354 = lean_ctor_get(x_206, 1);
+x_355 = lean_ctor_get(x_206, 2);
 lean_inc(x_355);
-x_356 = lean_ctor_get(x_325, 2);
+lean_inc(x_354);
+lean_dec(x_206);
+x_356 = lean_ctor_get(x_207, 0);
 lean_inc(x_356);
-x_357 = lean_ctor_get(x_325, 3);
+x_357 = lean_ctor_get(x_207, 1);
 lean_inc(x_357);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_358 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_358 = lean_box(0);
-}
-x_359 = lean_ctor_get(x_326, 0);
+x_358 = lean_ctor_get(x_207, 2);
+lean_inc(x_358);
+x_359 = lean_ctor_get(x_207, 3);
 lean_inc(x_359);
-x_360 = lean_ctor_get(x_326, 1);
-lean_inc(x_360);
-x_361 = lean_ctor_get(x_326, 2);
-lean_inc(x_361);
-x_362 = lean_ctor_get(x_326, 3);
-lean_inc(x_362);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_363 = x_326;
+if (lean_is_exclusive(x_207)) {
+ lean_ctor_release(x_207, 0);
+ lean_ctor_release(x_207, 1);
+ lean_ctor_release(x_207, 2);
+ lean_ctor_release(x_207, 3);
+ x_360 = x_207;
 } else {
- lean_dec_ref(x_326);
- x_363 = lean_box(0);
+ lean_dec_ref(x_207);
+ x_360 = lean_box(0);
 }
+if (lean_is_scalar(x_360)) {
+ x_361 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_361 = x_360;
+}
+lean_ctor_set(x_361, 0, x_356);
+lean_ctor_set(x_361, 1, x_357);
+lean_ctor_set(x_361, 2, x_358);
+lean_ctor_set(x_361, 3, x_359);
+lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_299);
+x_362 = 0;
+x_363 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_363, 0, x_361);
+lean_ctor_set(x_363, 1, x_354);
+lean_ctor_set(x_363, 2, x_355);
+lean_ctor_set(x_363, 3, x_288);
+lean_ctor_set_uint8(x_363, sizeof(void*)*4, x_362);
 x_364 = 1;
-if (lean_is_scalar(x_363)) {
- x_365 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_365 = x_363;
+lean_ctor_set(x_1, 0, x_363);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_364);
+return x_1;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_365, 0, x_315);
-lean_ctor_set(x_365, 1, x_316);
-lean_ctor_set(x_365, 2, x_317);
-lean_ctor_set(x_365, 3, x_359);
-lean_ctor_set_uint8(x_365, sizeof(void*)*4, x_364);
-if (lean_is_scalar(x_358)) {
- x_366 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_366 = x_358;
 }
-lean_ctor_set(x_366, 0, x_362);
-lean_ctor_set(x_366, 1, x_355);
-lean_ctor_set(x_366, 2, x_356);
-lean_ctor_set(x_366, 3, x_357);
-lean_ctor_set_uint8(x_366, sizeof(void*)*4, x_364);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_365);
-lean_ctor_set(x_367, 1, x_360);
-lean_ctor_set(x_367, 2, x_361);
-lean_ctor_set(x_367, 3, x_366);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_354);
-return x_367;
 }
 else
 {
-lean_object* x_368; 
-x_368 = lean_ctor_get(x_325, 3);
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; 
+x_365 = lean_ctor_get(x_1, 0);
+x_366 = lean_ctor_get(x_1, 1);
+x_367 = lean_ctor_get(x_1, 2);
+x_368 = lean_ctor_get(x_1, 3);
 lean_inc(x_368);
-if (lean_obj_tag(x_368) == 0)
+lean_inc(x_367);
+lean_inc(x_366);
+lean_inc(x_365);
+lean_dec(x_1);
+x_369 = lean_string_dec_lt(x_2, x_366);
+if (x_369 == 0)
 {
-lean_object* x_369; lean_object* x_370; lean_object* x_371; uint8_t x_372; lean_object* x_373; lean_object* x_374; 
-x_369 = lean_ctor_get(x_325, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_325, 2);
-lean_inc(x_370);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_371 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_371 = lean_box(0);
-}
-x_372 = 0;
-if (lean_is_scalar(x_371)) {
- x_373 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_373 = x_371;
-}
-lean_ctor_set(x_373, 0, x_326);
-lean_ctor_set(x_373, 1, x_369);
-lean_ctor_set(x_373, 2, x_370);
-lean_ctor_set(x_373, 3, x_368);
-lean_ctor_set_uint8(x_373, sizeof(void*)*4, x_372);
-x_374 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_374, 0, x_315);
-lean_ctor_set(x_374, 1, x_316);
-lean_ctor_set(x_374, 2, x_317);
-lean_ctor_set(x_374, 3, x_373);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_354);
-return x_374;
+uint8_t x_370; 
+x_370 = lean_string_dec_lt(x_366, x_2);
+if (x_370 == 0)
+{
+uint8_t x_371; lean_object* x_372; 
+lean_dec(x_367);
+lean_dec(x_366);
+x_371 = 1;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_365);
+lean_ctor_set(x_372, 1, x_2);
+lean_ctor_set(x_372, 2, x_3);
+lean_ctor_set(x_372, 3, x_368);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
 }
 else
 {
-uint8_t x_375; 
-x_375 = lean_ctor_get_uint8(x_368, sizeof(void*)*4);
-if (x_375 == 0)
+uint8_t x_373; 
+x_373 = l_Std_RBNode_isRed___rarg(x_368);
+if (x_373 == 0)
 {
-lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; 
-x_376 = lean_ctor_get(x_325, 1);
-lean_inc(x_376);
-x_377 = lean_ctor_get(x_325, 2);
-lean_inc(x_377);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_378 = x_325;
-} else {
- lean_dec_ref(x_325);
- x_378 = lean_box(0);
+lean_object* x_374; uint8_t x_375; lean_object* x_376; 
+x_374 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_368, x_2, x_3);
+x_375 = 1;
+x_376 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_376, 0, x_365);
+lean_ctor_set(x_376, 1, x_366);
+lean_ctor_set(x_376, 2, x_367);
+lean_ctor_set(x_376, 3, x_374);
+lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_375);
+return x_376;
 }
-x_379 = lean_ctor_get(x_368, 0);
+else
+{
+lean_object* x_377; lean_object* x_378; 
+x_377 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_368, x_2, x_3);
+x_378 = lean_ctor_get(x_377, 0);
+lean_inc(x_378);
+if (lean_obj_tag(x_378) == 0)
+{
+lean_object* x_379; 
+x_379 = lean_ctor_get(x_377, 3);
 lean_inc(x_379);
-x_380 = lean_ctor_get(x_368, 1);
+if (lean_obj_tag(x_379) == 0)
+{
+lean_object* x_380; lean_object* x_381; lean_object* x_382; uint8_t x_383; lean_object* x_384; uint8_t x_385; lean_object* x_386; 
+x_380 = lean_ctor_get(x_377, 1);
 lean_inc(x_380);
-x_381 = lean_ctor_get(x_368, 2);
+x_381 = lean_ctor_get(x_377, 2);
 lean_inc(x_381);
-x_382 = lean_ctor_get(x_368, 3);
-lean_inc(x_382);
-if (lean_is_exclusive(x_368)) {
- lean_ctor_release(x_368, 0);
- lean_ctor_release(x_368, 1);
- lean_ctor_release(x_368, 2);
- lean_ctor_release(x_368, 3);
- x_383 = x_368;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_382 = x_377;
 } else {
- lean_dec_ref(x_368);
- x_383 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_382 = lean_box(0);
 }
-lean_inc(x_326);
-if (lean_is_scalar(x_383)) {
+x_383 = 0;
+if (lean_is_scalar(x_382)) {
  x_384 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_384 = x_383;
+ x_384 = x_382;
 }
-lean_ctor_set(x_384, 0, x_315);
-lean_ctor_set(x_384, 1, x_316);
-lean_ctor_set(x_384, 2, x_317);
-lean_ctor_set(x_384, 3, x_326);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_385 = x_326;
-} else {
- lean_dec_ref(x_326);
- x_385 = lean_box(0);
-}
-lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_385)) {
- x_386 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_386 = x_385;
-}
-lean_ctor_set(x_386, 0, x_379);
-lean_ctor_set(x_386, 1, x_380);
-lean_ctor_set(x_386, 2, x_381);
-lean_ctor_set(x_386, 3, x_382);
-lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_354);
-if (lean_is_scalar(x_378)) {
- x_387 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_387 = x_378;
-}
-lean_ctor_set(x_387, 0, x_384);
-lean_ctor_set(x_387, 1, x_376);
-lean_ctor_set(x_387, 2, x_377);
-lean_ctor_set(x_387, 3, x_386);
-lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_375);
-return x_387;
+lean_ctor_set(x_384, 0, x_379);
+lean_ctor_set(x_384, 1, x_380);
+lean_ctor_set(x_384, 2, x_381);
+lean_ctor_set(x_384, 3, x_379);
+lean_ctor_set_uint8(x_384, sizeof(void*)*4, x_383);
+x_385 = 1;
+x_386 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_386, 0, x_365);
+lean_ctor_set(x_386, 1, x_366);
+lean_ctor_set(x_386, 2, x_367);
+lean_ctor_set(x_386, 3, x_384);
+lean_ctor_set_uint8(x_386, sizeof(void*)*4, x_385);
+return x_386;
 }
 else
 {
-lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; uint8_t x_397; lean_object* x_398; lean_object* x_399; 
-x_388 = lean_ctor_get(x_325, 1);
+uint8_t x_387; 
+x_387 = lean_ctor_get_uint8(x_379, sizeof(void*)*4);
+if (x_387 == 0)
+{
+lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; lean_object* x_400; 
+x_388 = lean_ctor_get(x_377, 1);
 lean_inc(x_388);
-x_389 = lean_ctor_get(x_325, 2);
+x_389 = lean_ctor_get(x_377, 2);
 lean_inc(x_389);
-if (lean_is_exclusive(x_325)) {
- lean_ctor_release(x_325, 0);
- lean_ctor_release(x_325, 1);
- lean_ctor_release(x_325, 2);
- lean_ctor_release(x_325, 3);
- x_390 = x_325;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_390 = x_377;
 } else {
- lean_dec_ref(x_325);
+ lean_dec_ref(x_377);
  x_390 = lean_box(0);
 }
-x_391 = lean_ctor_get(x_326, 0);
+x_391 = lean_ctor_get(x_379, 0);
 lean_inc(x_391);
-x_392 = lean_ctor_get(x_326, 1);
+x_392 = lean_ctor_get(x_379, 1);
 lean_inc(x_392);
-x_393 = lean_ctor_get(x_326, 2);
+x_393 = lean_ctor_get(x_379, 2);
 lean_inc(x_393);
-x_394 = lean_ctor_get(x_326, 3);
+x_394 = lean_ctor_get(x_379, 3);
 lean_inc(x_394);
-if (lean_is_exclusive(x_326)) {
- lean_ctor_release(x_326, 0);
- lean_ctor_release(x_326, 1);
- lean_ctor_release(x_326, 2);
- lean_ctor_release(x_326, 3);
- x_395 = x_326;
+if (lean_is_exclusive(x_379)) {
+ lean_ctor_release(x_379, 0);
+ lean_ctor_release(x_379, 1);
+ lean_ctor_release(x_379, 2);
+ lean_ctor_release(x_379, 3);
+ x_395 = x_379;
 } else {
- lean_dec_ref(x_326);
+ lean_dec_ref(x_379);
  x_395 = lean_box(0);
 }
+x_396 = 1;
 if (lean_is_scalar(x_395)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
+ x_397 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_396 = x_395;
+ x_397 = x_395;
 }
-lean_ctor_set(x_396, 0, x_391);
-lean_ctor_set(x_396, 1, x_392);
-lean_ctor_set(x_396, 2, x_393);
-lean_ctor_set(x_396, 3, x_394);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_375);
-x_397 = 0;
+lean_ctor_set(x_397, 0, x_365);
+lean_ctor_set(x_397, 1, x_366);
+lean_ctor_set(x_397, 2, x_367);
+lean_ctor_set(x_397, 3, x_378);
+lean_ctor_set_uint8(x_397, sizeof(void*)*4, x_396);
 if (lean_is_scalar(x_390)) {
  x_398 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_398 = x_390;
 }
-lean_ctor_set(x_398, 0, x_396);
-lean_ctor_set(x_398, 1, x_388);
-lean_ctor_set(x_398, 2, x_389);
-lean_ctor_set(x_398, 3, x_368);
-lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_397);
-x_399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_399, 0, x_315);
-lean_ctor_set(x_399, 1, x_316);
-lean_ctor_set(x_399, 2, x_317);
-lean_ctor_set(x_399, 3, x_398);
-lean_ctor_set_uint8(x_399, sizeof(void*)*4, x_375);
-return x_399;
-}
-}
-}
-}
-}
-}
+lean_ctor_set(x_398, 0, x_391);
+lean_ctor_set(x_398, 1, x_392);
+lean_ctor_set(x_398, 2, x_393);
+lean_ctor_set(x_398, 3, x_394);
+lean_ctor_set_uint8(x_398, sizeof(void*)*4, x_396);
+x_399 = 0;
+x_400 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_400, 0, x_397);
+lean_ctor_set(x_400, 1, x_388);
+lean_ctor_set(x_400, 2, x_389);
+lean_ctor_set(x_400, 3, x_398);
+lean_ctor_set_uint8(x_400, sizeof(void*)*4, x_399);
+return x_400;
 }
 else
 {
-uint8_t x_400; 
-x_400 = l_Std_RBNode_isRed___rarg(x_315);
-if (x_400 == 0)
-{
-lean_object* x_401; lean_object* x_402; 
-x_401 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_315, x_2, x_3);
-x_402 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_402, 0, x_401);
-lean_ctor_set(x_402, 1, x_316);
-lean_ctor_set(x_402, 2, x_317);
-lean_ctor_set(x_402, 3, x_318);
-lean_ctor_set_uint8(x_402, sizeof(void*)*4, x_6);
-return x_402;
-}
-else
-{
-lean_object* x_403; lean_object* x_404; 
-x_403 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_315, x_2, x_3);
-x_404 = lean_ctor_get(x_403, 0);
-lean_inc(x_404);
-if (lean_obj_tag(x_404) == 0)
-{
-lean_object* x_405; 
-x_405 = lean_ctor_get(x_403, 3);
-lean_inc(x_405);
-if (lean_obj_tag(x_405) == 0)
-{
-lean_object* x_406; lean_object* x_407; lean_object* x_408; uint8_t x_409; lean_object* x_410; uint8_t x_411; lean_object* x_412; 
-x_406 = lean_ctor_get(x_403, 1);
-lean_inc(x_406);
-x_407 = lean_ctor_get(x_403, 2);
-lean_inc(x_407);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_408 = x_403;
+lean_object* x_401; lean_object* x_402; lean_object* x_403; uint8_t x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; 
+x_401 = lean_ctor_get(x_377, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_377, 2);
+lean_inc(x_402);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_403 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_408 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_403 = lean_box(0);
 }
-x_409 = 0;
-if (lean_is_scalar(x_408)) {
- x_410 = lean_alloc_ctor(1, 4, 1);
+x_404 = 0;
+if (lean_is_scalar(x_403)) {
+ x_405 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_410 = x_408;
+ x_405 = x_403;
+}
+lean_ctor_set(x_405, 0, x_378);
+lean_ctor_set(x_405, 1, x_401);
+lean_ctor_set(x_405, 2, x_402);
+lean_ctor_set(x_405, 3, x_379);
+lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_404);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_365);
+lean_ctor_set(x_407, 1, x_366);
+lean_ctor_set(x_407, 2, x_367);
+lean_ctor_set(x_407, 3, x_405);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+return x_407;
+}
 }
-lean_ctor_set(x_410, 0, x_405);
-lean_ctor_set(x_410, 1, x_406);
-lean_ctor_set(x_410, 2, x_407);
-lean_ctor_set(x_410, 3, x_405);
-lean_ctor_set_uint8(x_410, sizeof(void*)*4, x_409);
-x_411 = 1;
-x_412 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_412, 0, x_410);
-lean_ctor_set(x_412, 1, x_316);
-lean_ctor_set(x_412, 2, x_317);
-lean_ctor_set(x_412, 3, x_318);
-lean_ctor_set_uint8(x_412, sizeof(void*)*4, x_411);
-return x_412;
 }
 else
 {
-uint8_t x_413; 
-x_413 = lean_ctor_get_uint8(x_405, sizeof(void*)*4);
-if (x_413 == 0)
+uint8_t x_408; 
+x_408 = lean_ctor_get_uint8(x_378, sizeof(void*)*4);
+if (x_408 == 0)
 {
-lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; uint8_t x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; 
-x_414 = lean_ctor_get(x_403, 1);
+lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; lean_object* x_420; uint8_t x_421; lean_object* x_422; 
+x_409 = lean_ctor_get(x_377, 1);
+lean_inc(x_409);
+x_410 = lean_ctor_get(x_377, 2);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_377, 3);
+lean_inc(x_411);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_412 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_412 = lean_box(0);
+}
+x_413 = lean_ctor_get(x_378, 0);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_378, 1);
 lean_inc(x_414);
-x_415 = lean_ctor_get(x_403, 2);
+x_415 = lean_ctor_get(x_378, 2);
 lean_inc(x_415);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_416 = x_403;
+x_416 = lean_ctor_get(x_378, 3);
+lean_inc(x_416);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_417 = x_378;
 } else {
- lean_dec_ref(x_403);
- x_416 = lean_box(0);
+ lean_dec_ref(x_378);
+ x_417 = lean_box(0);
 }
-x_417 = lean_ctor_get(x_405, 0);
-lean_inc(x_417);
-x_418 = lean_ctor_get(x_405, 1);
-lean_inc(x_418);
-x_419 = lean_ctor_get(x_405, 2);
-lean_inc(x_419);
-x_420 = lean_ctor_get(x_405, 3);
-lean_inc(x_420);
-if (lean_is_exclusive(x_405)) {
- lean_ctor_release(x_405, 0);
- lean_ctor_release(x_405, 1);
- lean_ctor_release(x_405, 2);
- lean_ctor_release(x_405, 3);
- x_421 = x_405;
+x_418 = 1;
+if (lean_is_scalar(x_417)) {
+ x_419 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_405);
- x_421 = lean_box(0);
+ x_419 = x_417;
 }
-x_422 = 1;
-if (lean_is_scalar(x_421)) {
- x_423 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_419, 0, x_365);
+lean_ctor_set(x_419, 1, x_366);
+lean_ctor_set(x_419, 2, x_367);
+lean_ctor_set(x_419, 3, x_413);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
+if (lean_is_scalar(x_412)) {
+ x_420 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_423 = x_421;
+ x_420 = x_412;
 }
-lean_ctor_set(x_423, 0, x_404);
-lean_ctor_set(x_423, 1, x_414);
-lean_ctor_set(x_423, 2, x_415);
-lean_ctor_set(x_423, 3, x_417);
-lean_ctor_set_uint8(x_423, sizeof(void*)*4, x_422);
-if (lean_is_scalar(x_416)) {
- x_424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_424 = x_416;
-}
-lean_ctor_set(x_424, 0, x_420);
-lean_ctor_set(x_424, 1, x_316);
-lean_ctor_set(x_424, 2, x_317);
-lean_ctor_set(x_424, 3, x_318);
-lean_ctor_set_uint8(x_424, sizeof(void*)*4, x_422);
-x_425 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_425, 0, x_423);
-lean_ctor_set(x_425, 1, x_418);
-lean_ctor_set(x_425, 2, x_419);
-lean_ctor_set(x_425, 3, x_424);
-lean_ctor_set_uint8(x_425, sizeof(void*)*4, x_413);
-return x_425;
+lean_ctor_set(x_420, 0, x_416);
+lean_ctor_set(x_420, 1, x_409);
+lean_ctor_set(x_420, 2, x_410);
+lean_ctor_set(x_420, 3, x_411);
+lean_ctor_set_uint8(x_420, sizeof(void*)*4, x_418);
+x_421 = 0;
+x_422 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_422, 0, x_419);
+lean_ctor_set(x_422, 1, x_414);
+lean_ctor_set(x_422, 2, x_415);
+lean_ctor_set(x_422, 3, x_420);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_421);
+return x_422;
 }
 else
 {
-lean_object* x_426; lean_object* x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; lean_object* x_431; 
-x_426 = lean_ctor_get(x_403, 1);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_403, 2);
-lean_inc(x_427);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_428 = x_403;
+lean_object* x_423; 
+x_423 = lean_ctor_get(x_377, 3);
+lean_inc(x_423);
+if (lean_obj_tag(x_423) == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; uint8_t x_429; lean_object* x_430; 
+x_424 = lean_ctor_get(x_377, 1);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_377, 2);
+lean_inc(x_425);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_426 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_428 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_426 = lean_box(0);
 }
-x_429 = 0;
-if (lean_is_scalar(x_428)) {
- x_430 = lean_alloc_ctor(1, 4, 1);
+x_427 = 0;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_430 = x_428;
+ x_428 = x_426;
 }
-lean_ctor_set(x_430, 0, x_404);
-lean_ctor_set(x_430, 1, x_426);
-lean_ctor_set(x_430, 2, x_427);
-lean_ctor_set(x_430, 3, x_405);
+lean_ctor_set(x_428, 0, x_378);
+lean_ctor_set(x_428, 1, x_424);
+lean_ctor_set(x_428, 2, x_425);
+lean_ctor_set(x_428, 3, x_423);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_365);
+lean_ctor_set(x_430, 1, x_366);
+lean_ctor_set(x_430, 2, x_367);
+lean_ctor_set(x_430, 3, x_428);
 lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
-x_431 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_431, 0, x_430);
-lean_ctor_set(x_431, 1, x_316);
-lean_ctor_set(x_431, 2, x_317);
-lean_ctor_set(x_431, 3, x_318);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_413);
-return x_431;
-}
-}
+return x_430;
 }
 else
 {
-uint8_t x_432; 
-x_432 = lean_ctor_get_uint8(x_404, sizeof(void*)*4);
-if (x_432 == 0)
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_423, sizeof(void*)*4);
+if (x_431 == 0)
 {
-lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; uint8_t x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; 
-x_433 = lean_ctor_get(x_403, 1);
+lean_object* x_432; lean_object* x_433; lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; uint8_t x_444; lean_object* x_445; 
+x_432 = lean_ctor_get(x_377, 1);
+lean_inc(x_432);
+x_433 = lean_ctor_get(x_377, 2);
 lean_inc(x_433);
-x_434 = lean_ctor_get(x_403, 2);
-lean_inc(x_434);
-x_435 = lean_ctor_get(x_403, 3);
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_434 = x_377;
+} else {
+ lean_dec_ref(x_377);
+ x_434 = lean_box(0);
+}
+x_435 = lean_ctor_get(x_423, 0);
 lean_inc(x_435);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_436 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_436 = lean_box(0);
-}
-x_437 = lean_ctor_get(x_404, 0);
+x_436 = lean_ctor_get(x_423, 1);
+lean_inc(x_436);
+x_437 = lean_ctor_get(x_423, 2);
 lean_inc(x_437);
-x_438 = lean_ctor_get(x_404, 1);
+x_438 = lean_ctor_get(x_423, 3);
 lean_inc(x_438);
-x_439 = lean_ctor_get(x_404, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_404, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_441 = x_404;
+if (lean_is_exclusive(x_423)) {
+ lean_ctor_release(x_423, 0);
+ lean_ctor_release(x_423, 1);
+ lean_ctor_release(x_423, 2);
+ lean_ctor_release(x_423, 3);
+ x_439 = x_423;
 } else {
- lean_dec_ref(x_404);
- x_441 = lean_box(0);
+ lean_dec_ref(x_423);
+ x_439 = lean_box(0);
 }
-x_442 = 1;
-if (lean_is_scalar(x_441)) {
+x_440 = 1;
+lean_inc(x_378);
+if (lean_is_scalar(x_439)) {
+ x_441 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_441 = x_439;
+}
+lean_ctor_set(x_441, 0, x_365);
+lean_ctor_set(x_441, 1, x_366);
+lean_ctor_set(x_441, 2, x_367);
+lean_ctor_set(x_441, 3, x_378);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_442 = x_378;
+} else {
+ lean_dec_ref(x_378);
+ x_442 = lean_box(0);
+}
+lean_ctor_set_uint8(x_441, sizeof(void*)*4, x_440);
+if (lean_is_scalar(x_442)) {
  x_443 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_443 = x_441;
+ x_443 = x_442;
 }
-lean_ctor_set(x_443, 0, x_437);
-lean_ctor_set(x_443, 1, x_438);
-lean_ctor_set(x_443, 2, x_439);
-lean_ctor_set(x_443, 3, x_440);
-lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_442);
-if (lean_is_scalar(x_436)) {
- x_444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_443, 0, x_435);
+lean_ctor_set(x_443, 1, x_436);
+lean_ctor_set(x_443, 2, x_437);
+lean_ctor_set(x_443, 3, x_438);
+lean_ctor_set_uint8(x_443, sizeof(void*)*4, x_440);
+x_444 = 0;
+if (lean_is_scalar(x_434)) {
+ x_445 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_444 = x_436;
+ x_445 = x_434;
 }
-lean_ctor_set(x_444, 0, x_435);
-lean_ctor_set(x_444, 1, x_316);
-lean_ctor_set(x_444, 2, x_317);
-lean_ctor_set(x_444, 3, x_318);
-lean_ctor_set_uint8(x_444, sizeof(void*)*4, x_442);
-x_445 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_445, 0, x_443);
-lean_ctor_set(x_445, 1, x_433);
-lean_ctor_set(x_445, 2, x_434);
-lean_ctor_set(x_445, 3, x_444);
-lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_432);
+lean_ctor_set(x_445, 0, x_441);
+lean_ctor_set(x_445, 1, x_432);
+lean_ctor_set(x_445, 2, x_433);
+lean_ctor_set(x_445, 3, x_443);
+lean_ctor_set_uint8(x_445, sizeof(void*)*4, x_444);
 return x_445;
 }
 else
 {
-lean_object* x_446; 
-x_446 = lean_ctor_get(x_403, 3);
+lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; uint8_t x_455; lean_object* x_456; uint8_t x_457; lean_object* x_458; 
+x_446 = lean_ctor_get(x_377, 1);
 lean_inc(x_446);
-if (lean_obj_tag(x_446) == 0)
-{
-lean_object* x_447; lean_object* x_448; lean_object* x_449; uint8_t x_450; lean_object* x_451; lean_object* x_452; 
-x_447 = lean_ctor_get(x_403, 1);
+x_447 = lean_ctor_get(x_377, 2);
 lean_inc(x_447);
-x_448 = lean_ctor_get(x_403, 2);
-lean_inc(x_448);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_449 = x_403;
+if (lean_is_exclusive(x_377)) {
+ lean_ctor_release(x_377, 0);
+ lean_ctor_release(x_377, 1);
+ lean_ctor_release(x_377, 2);
+ lean_ctor_release(x_377, 3);
+ x_448 = x_377;
 } else {
- lean_dec_ref(x_403);
- x_449 = lean_box(0);
+ lean_dec_ref(x_377);
+ x_448 = lean_box(0);
 }
-x_450 = 0;
-if (lean_is_scalar(x_449)) {
- x_451 = lean_alloc_ctor(1, 4, 1);
+x_449 = lean_ctor_get(x_378, 0);
+lean_inc(x_449);
+x_450 = lean_ctor_get(x_378, 1);
+lean_inc(x_450);
+x_451 = lean_ctor_get(x_378, 2);
+lean_inc(x_451);
+x_452 = lean_ctor_get(x_378, 3);
+lean_inc(x_452);
+if (lean_is_exclusive(x_378)) {
+ lean_ctor_release(x_378, 0);
+ lean_ctor_release(x_378, 1);
+ lean_ctor_release(x_378, 2);
+ lean_ctor_release(x_378, 3);
+ x_453 = x_378;
 } else {
- x_451 = x_449;
+ lean_dec_ref(x_378);
+ x_453 = lean_box(0);
+}
+if (lean_is_scalar(x_453)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_453;
+}
+lean_ctor_set(x_454, 0, x_449);
+lean_ctor_set(x_454, 1, x_450);
+lean_ctor_set(x_454, 2, x_451);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_431);
+x_455 = 0;
+if (lean_is_scalar(x_448)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_448;
+}
+lean_ctor_set(x_456, 0, x_454);
+lean_ctor_set(x_456, 1, x_446);
+lean_ctor_set(x_456, 2, x_447);
+lean_ctor_set(x_456, 3, x_423);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_455);
+x_457 = 1;
+x_458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_458, 0, x_365);
+lean_ctor_set(x_458, 1, x_366);
+lean_ctor_set(x_458, 2, x_367);
+lean_ctor_set(x_458, 3, x_456);
+lean_ctor_set_uint8(x_458, sizeof(void*)*4, x_457);
+return x_458;
+}
+}
+}
+}
+}
 }
-lean_ctor_set(x_451, 0, x_404);
-lean_ctor_set(x_451, 1, x_447);
-lean_ctor_set(x_451, 2, x_448);
-lean_ctor_set(x_451, 3, x_446);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_450);
-x_452 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_452, 0, x_451);
-lean_ctor_set(x_452, 1, x_316);
-lean_ctor_set(x_452, 2, x_317);
-lean_ctor_set(x_452, 3, x_318);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_432);
-return x_452;
 }
 else
 {
-uint8_t x_453; 
-x_453 = lean_ctor_get_uint8(x_446, sizeof(void*)*4);
-if (x_453 == 0)
+uint8_t x_459; 
+x_459 = l_Std_RBNode_isRed___rarg(x_365);
+if (x_459 == 0)
 {
-lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; 
-x_454 = lean_ctor_get(x_403, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_403, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_456 = x_403;
-} else {
- lean_dec_ref(x_403);
- x_456 = lean_box(0);
-}
-x_457 = lean_ctor_get(x_446, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_446, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_446, 2);
-lean_inc(x_459);
-x_460 = lean_ctor_get(x_446, 3);
-lean_inc(x_460);
-if (lean_is_exclusive(x_446)) {
- lean_ctor_release(x_446, 0);
- lean_ctor_release(x_446, 1);
- lean_ctor_release(x_446, 2);
- lean_ctor_release(x_446, 3);
- x_461 = x_446;
-} else {
- lean_dec_ref(x_446);
- x_461 = lean_box(0);
-}
-lean_inc(x_404);
-if (lean_is_scalar(x_461)) {
- x_462 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_462 = x_461;
-}
-lean_ctor_set(x_462, 0, x_404);
-lean_ctor_set(x_462, 1, x_454);
-lean_ctor_set(x_462, 2, x_455);
-lean_ctor_set(x_462, 3, x_457);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_463 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_463 = lean_box(0);
-}
-lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_463)) {
- x_464 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_464 = x_463;
-}
-lean_ctor_set(x_464, 0, x_460);
-lean_ctor_set(x_464, 1, x_316);
-lean_ctor_set(x_464, 2, x_317);
-lean_ctor_set(x_464, 3, x_318);
-lean_ctor_set_uint8(x_464, sizeof(void*)*4, x_432);
-if (lean_is_scalar(x_456)) {
- x_465 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_465 = x_456;
-}
-lean_ctor_set(x_465, 0, x_462);
-lean_ctor_set(x_465, 1, x_458);
-lean_ctor_set(x_465, 2, x_459);
-lean_ctor_set(x_465, 3, x_464);
-lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_453);
-return x_465;
+lean_object* x_460; uint8_t x_461; lean_object* x_462; 
+x_460 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_365, x_2, x_3);
+x_461 = 1;
+x_462 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_462, 0, x_460);
+lean_ctor_set(x_462, 1, x_366);
+lean_ctor_set(x_462, 2, x_367);
+lean_ctor_set(x_462, 3, x_368);
+lean_ctor_set_uint8(x_462, sizeof(void*)*4, x_461);
+return x_462;
 }
 else
 {
-lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; uint8_t x_475; lean_object* x_476; lean_object* x_477; 
-x_466 = lean_ctor_get(x_403, 1);
+lean_object* x_463; lean_object* x_464; 
+x_463 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_365, x_2, x_3);
+x_464 = lean_ctor_get(x_463, 0);
+lean_inc(x_464);
+if (lean_obj_tag(x_464) == 0)
+{
+lean_object* x_465; 
+x_465 = lean_ctor_get(x_463, 3);
+lean_inc(x_465);
+if (lean_obj_tag(x_465) == 0)
+{
+lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; uint8_t x_471; lean_object* x_472; 
+x_466 = lean_ctor_get(x_463, 1);
 lean_inc(x_466);
-x_467 = lean_ctor_get(x_403, 2);
+x_467 = lean_ctor_get(x_463, 2);
 lean_inc(x_467);
-if (lean_is_exclusive(x_403)) {
- lean_ctor_release(x_403, 0);
- lean_ctor_release(x_403, 1);
- lean_ctor_release(x_403, 2);
- lean_ctor_release(x_403, 3);
- x_468 = x_403;
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_468 = x_463;
 } else {
- lean_dec_ref(x_403);
+ lean_dec_ref(x_463);
  x_468 = lean_box(0);
 }
-x_469 = lean_ctor_get(x_404, 0);
-lean_inc(x_469);
-x_470 = lean_ctor_get(x_404, 1);
-lean_inc(x_470);
-x_471 = lean_ctor_get(x_404, 2);
-lean_inc(x_471);
-x_472 = lean_ctor_get(x_404, 3);
-lean_inc(x_472);
-if (lean_is_exclusive(x_404)) {
- lean_ctor_release(x_404, 0);
- lean_ctor_release(x_404, 1);
- lean_ctor_release(x_404, 2);
- lean_ctor_release(x_404, 3);
- x_473 = x_404;
-} else {
- lean_dec_ref(x_404);
- x_473 = lean_box(0);
-}
-if (lean_is_scalar(x_473)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_473;
-}
-lean_ctor_set(x_474, 0, x_469);
-lean_ctor_set(x_474, 1, x_470);
-lean_ctor_set(x_474, 2, x_471);
-lean_ctor_set(x_474, 3, x_472);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_453);
-x_475 = 0;
+x_469 = 0;
 if (lean_is_scalar(x_468)) {
- x_476 = lean_alloc_ctor(1, 4, 1);
+ x_470 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_476 = x_468;
+ x_470 = x_468;
 }
-lean_ctor_set(x_476, 0, x_474);
-lean_ctor_set(x_476, 1, x_466);
-lean_ctor_set(x_476, 2, x_467);
-lean_ctor_set(x_476, 3, x_446);
-lean_ctor_set_uint8(x_476, sizeof(void*)*4, x_475);
-x_477 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_477, 0, x_476);
-lean_ctor_set(x_477, 1, x_316);
-lean_ctor_set(x_477, 2, x_317);
-lean_ctor_set(x_477, 3, x_318);
-lean_ctor_set_uint8(x_477, sizeof(void*)*4, x_453);
-return x_477;
+lean_ctor_set(x_470, 0, x_465);
+lean_ctor_set(x_470, 1, x_466);
+lean_ctor_set(x_470, 2, x_467);
+lean_ctor_set(x_470, 3, x_465);
+lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
+x_471 = 1;
+x_472 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_472, 0, x_470);
+lean_ctor_set(x_472, 1, x_366);
+lean_ctor_set(x_472, 2, x_367);
+lean_ctor_set(x_472, 3, x_368);
+lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_471);
+return x_472;
+}
+else
+{
+uint8_t x_473; 
+x_473 = lean_ctor_get_uint8(x_465, sizeof(void*)*4);
+if (x_473 == 0)
+{
+lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; uint8_t x_482; lean_object* x_483; lean_object* x_484; uint8_t x_485; lean_object* x_486; 
+x_474 = lean_ctor_get(x_463, 1);
+lean_inc(x_474);
+x_475 = lean_ctor_get(x_463, 2);
+lean_inc(x_475);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_476 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_476 = lean_box(0);
+}
+x_477 = lean_ctor_get(x_465, 0);
+lean_inc(x_477);
+x_478 = lean_ctor_get(x_465, 1);
+lean_inc(x_478);
+x_479 = lean_ctor_get(x_465, 2);
+lean_inc(x_479);
+x_480 = lean_ctor_get(x_465, 3);
+lean_inc(x_480);
+if (lean_is_exclusive(x_465)) {
+ lean_ctor_release(x_465, 0);
+ lean_ctor_release(x_465, 1);
+ lean_ctor_release(x_465, 2);
+ lean_ctor_release(x_465, 3);
+ x_481 = x_465;
+} else {
+ lean_dec_ref(x_465);
+ x_481 = lean_box(0);
+}
+x_482 = 1;
+if (lean_is_scalar(x_481)) {
+ x_483 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_483 = x_481;
+}
+lean_ctor_set(x_483, 0, x_464);
+lean_ctor_set(x_483, 1, x_474);
+lean_ctor_set(x_483, 2, x_475);
+lean_ctor_set(x_483, 3, x_477);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_482);
+if (lean_is_scalar(x_476)) {
+ x_484 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_484 = x_476;
+}
+lean_ctor_set(x_484, 0, x_480);
+lean_ctor_set(x_484, 1, x_366);
+lean_ctor_set(x_484, 2, x_367);
+lean_ctor_set(x_484, 3, x_368);
+lean_ctor_set_uint8(x_484, sizeof(void*)*4, x_482);
+x_485 = 0;
+x_486 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_486, 0, x_483);
+lean_ctor_set(x_486, 1, x_478);
+lean_ctor_set(x_486, 2, x_479);
+lean_ctor_set(x_486, 3, x_484);
+lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_485);
+return x_486;
+}
+else
+{
+lean_object* x_487; lean_object* x_488; lean_object* x_489; uint8_t x_490; lean_object* x_491; uint8_t x_492; lean_object* x_493; 
+x_487 = lean_ctor_get(x_463, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_463, 2);
+lean_inc(x_488);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_489 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_489 = lean_box(0);
+}
+x_490 = 0;
+if (lean_is_scalar(x_489)) {
+ x_491 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_491 = x_489;
+}
+lean_ctor_set(x_491, 0, x_464);
+lean_ctor_set(x_491, 1, x_487);
+lean_ctor_set(x_491, 2, x_488);
+lean_ctor_set(x_491, 3, x_465);
+lean_ctor_set_uint8(x_491, sizeof(void*)*4, x_490);
+x_492 = 1;
+x_493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_493, 0, x_491);
+lean_ctor_set(x_493, 1, x_366);
+lean_ctor_set(x_493, 2, x_367);
+lean_ctor_set(x_493, 3, x_368);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_492);
+return x_493;
+}
+}
+}
+else
+{
+uint8_t x_494; 
+x_494 = lean_ctor_get_uint8(x_464, sizeof(void*)*4);
+if (x_494 == 0)
+{
+lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; uint8_t x_504; lean_object* x_505; lean_object* x_506; uint8_t x_507; lean_object* x_508; 
+x_495 = lean_ctor_get(x_463, 1);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_463, 2);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_463, 3);
+lean_inc(x_497);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_498 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_498 = lean_box(0);
+}
+x_499 = lean_ctor_get(x_464, 0);
+lean_inc(x_499);
+x_500 = lean_ctor_get(x_464, 1);
+lean_inc(x_500);
+x_501 = lean_ctor_get(x_464, 2);
+lean_inc(x_501);
+x_502 = lean_ctor_get(x_464, 3);
+lean_inc(x_502);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_503 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_503 = lean_box(0);
+}
+x_504 = 1;
+if (lean_is_scalar(x_503)) {
+ x_505 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_505 = x_503;
+}
+lean_ctor_set(x_505, 0, x_499);
+lean_ctor_set(x_505, 1, x_500);
+lean_ctor_set(x_505, 2, x_501);
+lean_ctor_set(x_505, 3, x_502);
+lean_ctor_set_uint8(x_505, sizeof(void*)*4, x_504);
+if (lean_is_scalar(x_498)) {
+ x_506 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_506 = x_498;
+}
+lean_ctor_set(x_506, 0, x_497);
+lean_ctor_set(x_506, 1, x_366);
+lean_ctor_set(x_506, 2, x_367);
+lean_ctor_set(x_506, 3, x_368);
+lean_ctor_set_uint8(x_506, sizeof(void*)*4, x_504);
+x_507 = 0;
+x_508 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_508, 0, x_505);
+lean_ctor_set(x_508, 1, x_495);
+lean_ctor_set(x_508, 2, x_496);
+lean_ctor_set(x_508, 3, x_506);
+lean_ctor_set_uint8(x_508, sizeof(void*)*4, x_507);
+return x_508;
+}
+else
+{
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_463, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
+{
+lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; uint8_t x_515; lean_object* x_516; 
+x_510 = lean_ctor_get(x_463, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_463, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_512 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_512 = lean_box(0);
+}
+x_513 = 0;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_464);
+lean_ctor_set(x_514, 1, x_510);
+lean_ctor_set(x_514, 2, x_511);
+lean_ctor_set(x_514, 3, x_509);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+x_515 = 1;
+x_516 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_516, 0, x_514);
+lean_ctor_set(x_516, 1, x_366);
+lean_ctor_set(x_516, 2, x_367);
+lean_ctor_set(x_516, 3, x_368);
+lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_515);
+return x_516;
+}
+else
+{
+uint8_t x_517; 
+x_517 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_517 == 0)
+{
+lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; uint8_t x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; uint8_t x_530; lean_object* x_531; 
+x_518 = lean_ctor_get(x_463, 1);
+lean_inc(x_518);
+x_519 = lean_ctor_get(x_463, 2);
+lean_inc(x_519);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_520 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_520 = lean_box(0);
+}
+x_521 = lean_ctor_get(x_509, 0);
+lean_inc(x_521);
+x_522 = lean_ctor_get(x_509, 1);
+lean_inc(x_522);
+x_523 = lean_ctor_get(x_509, 2);
+lean_inc(x_523);
+x_524 = lean_ctor_get(x_509, 3);
+lean_inc(x_524);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_525 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_525 = lean_box(0);
+}
+x_526 = 1;
+lean_inc(x_464);
+if (lean_is_scalar(x_525)) {
+ x_527 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_527 = x_525;
+}
+lean_ctor_set(x_527, 0, x_464);
+lean_ctor_set(x_527, 1, x_518);
+lean_ctor_set(x_527, 2, x_519);
+lean_ctor_set(x_527, 3, x_521);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_528 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_528 = lean_box(0);
+}
+lean_ctor_set_uint8(x_527, sizeof(void*)*4, x_526);
+if (lean_is_scalar(x_528)) {
+ x_529 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_529 = x_528;
+}
+lean_ctor_set(x_529, 0, x_524);
+lean_ctor_set(x_529, 1, x_366);
+lean_ctor_set(x_529, 2, x_367);
+lean_ctor_set(x_529, 3, x_368);
+lean_ctor_set_uint8(x_529, sizeof(void*)*4, x_526);
+x_530 = 0;
+if (lean_is_scalar(x_520)) {
+ x_531 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_531 = x_520;
+}
+lean_ctor_set(x_531, 0, x_527);
+lean_ctor_set(x_531, 1, x_522);
+lean_ctor_set(x_531, 2, x_523);
+lean_ctor_set(x_531, 3, x_529);
+lean_ctor_set_uint8(x_531, sizeof(void*)*4, x_530);
+return x_531;
+}
+else
+{
+lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; uint8_t x_543; lean_object* x_544; 
+x_532 = lean_ctor_get(x_463, 1);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_463, 2);
+lean_inc(x_533);
+if (lean_is_exclusive(x_463)) {
+ lean_ctor_release(x_463, 0);
+ lean_ctor_release(x_463, 1);
+ lean_ctor_release(x_463, 2);
+ lean_ctor_release(x_463, 3);
+ x_534 = x_463;
+} else {
+ lean_dec_ref(x_463);
+ x_534 = lean_box(0);
+}
+x_535 = lean_ctor_get(x_464, 0);
+lean_inc(x_535);
+x_536 = lean_ctor_get(x_464, 1);
+lean_inc(x_536);
+x_537 = lean_ctor_get(x_464, 2);
+lean_inc(x_537);
+x_538 = lean_ctor_get(x_464, 3);
+lean_inc(x_538);
+if (lean_is_exclusive(x_464)) {
+ lean_ctor_release(x_464, 0);
+ lean_ctor_release(x_464, 1);
+ lean_ctor_release(x_464, 2);
+ lean_ctor_release(x_464, 3);
+ x_539 = x_464;
+} else {
+ lean_dec_ref(x_464);
+ x_539 = lean_box(0);
+}
+if (lean_is_scalar(x_539)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_539;
+}
+lean_ctor_set(x_540, 0, x_535);
+lean_ctor_set(x_540, 1, x_536);
+lean_ctor_set(x_540, 2, x_537);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_517);
+x_541 = 0;
+if (lean_is_scalar(x_534)) {
+ x_542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_542 = x_534;
+}
+lean_ctor_set(x_542, 0, x_540);
+lean_ctor_set(x_542, 1, x_532);
+lean_ctor_set(x_542, 2, x_533);
+lean_ctor_set(x_542, 3, x_509);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+x_543 = 1;
+x_544 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_544, 0, x_542);
+lean_ctor_set(x_544, 1, x_366);
+lean_ctor_set(x_544, 2, x_367);
+lean_ctor_set(x_544, 3, x_368);
+lean_ctor_set_uint8(x_544, sizeof(void*)*4, x_543);
+return x_544;
 }
 }
 }
@@ -3212,13 +3289,13 @@ x_4 = l_Std_RBNode_isRed___rarg(x_1);
 if (x_4 == 0)
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_1, x_2, x_3);
+x_5 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_1, x_2, x_3);
 return x_5;
 }
 else
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBNode_ins___main___at_Lean_Server_updateOpenDocuments___spec__2(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_ins___at_Lean_Server_updateOpenDocuments___spec__2(x_1, x_2, x_3);
 x_7 = l_Std_RBNode_setBlack___rarg(x_6);
 return x_7;
 }
@@ -4764,158 +4841,160 @@ lean_dec(x_5);
 return x_9;
 }
 }
-lean_object* l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
 {
-return x_2;
+lean_object* x_3; 
+x_3 = lean_box(0);
+return x_3;
 }
 else
 {
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_2);
+if (x_4 == 0)
 {
-lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; uint8_t x_8; 
-x_4 = lean_ctor_get(x_2, 0);
-x_5 = lean_ctor_get(x_2, 1);
-x_6 = lean_ctor_get(x_2, 2);
-x_7 = lean_ctor_get(x_2, 3);
-x_8 = lean_string_dec_lt(x_1, x_5);
-if (x_8 == 0)
-{
-uint8_t x_9; 
-x_9 = lean_string_dec_lt(x_5, x_1);
+lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
+x_5 = lean_ctor_get(x_2, 0);
+x_6 = lean_ctor_get(x_2, 1);
+x_7 = lean_ctor_get(x_2, 2);
+x_8 = lean_ctor_get(x_2, 3);
+x_9 = lean_string_dec_lt(x_1, x_6);
 if (x_9 == 0)
 {
-lean_object* x_10; 
+uint8_t x_10; 
+x_10 = lean_string_dec_lt(x_6, x_1);
+if (x_10 == 0)
+{
+lean_object* x_11; 
 lean_free_object(x_2);
+lean_dec(x_7);
 lean_dec(x_6);
-lean_dec(x_5);
-x_10 = l_Std_RBNode_appendTrees___main___rarg(x_4, x_7);
-return x_10;
+x_11 = l_Std_RBNode_appendTrees___rarg(x_5, x_8);
+return x_11;
 }
 else
 {
-uint8_t x_11; 
-x_11 = l_Std_RBNode_isBlack___rarg(x_7);
-if (x_11 == 0)
+uint8_t x_12; 
+x_12 = l_Std_RBNode_isBlack___rarg(x_8);
+if (x_12 == 0)
 {
-lean_object* x_12; uint8_t x_13; 
-x_12 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_7);
-x_13 = 0;
-lean_ctor_set(x_2, 3, x_12);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_13);
+lean_object* x_13; uint8_t x_14; 
+x_13 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_8);
+x_14 = 0;
+lean_ctor_set(x_2, 3, x_13);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_14);
 return x_2;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; 
+lean_object* x_15; lean_object* x_16; 
 lean_free_object(x_2);
-x_14 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_7);
-x_15 = l_Std_RBNode_balRight___rarg(x_4, x_5, x_6, x_14);
-return x_15;
+x_15 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_8);
+x_16 = l_Std_RBNode_balRight___rarg(x_5, x_6, x_7, x_15);
+return x_16;
 }
 }
 }
 else
 {
-uint8_t x_16; 
-x_16 = l_Std_RBNode_isBlack___rarg(x_4);
-if (x_16 == 0)
+uint8_t x_17; 
+x_17 = l_Std_RBNode_isBlack___rarg(x_5);
+if (x_17 == 0)
 {
-lean_object* x_17; uint8_t x_18; 
-x_17 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_4);
-x_18 = 0;
-lean_ctor_set(x_2, 0, x_17);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_18);
+lean_object* x_18; uint8_t x_19; 
+x_18 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_5);
+x_19 = 0;
+lean_ctor_set(x_2, 0, x_18);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_19);
 return x_2;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; 
+lean_object* x_20; lean_object* x_21; 
 lean_free_object(x_2);
-x_19 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_4);
-x_20 = l_Std_RBNode_balLeft___rarg(x_19, x_5, x_6, x_7);
-return x_20;
+x_20 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_5);
+x_21 = l_Std_RBNode_balLeft___rarg(x_20, x_6, x_7, x_8);
+return x_21;
 }
 }
 }
 else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_21 = lean_ctor_get(x_2, 0);
-x_22 = lean_ctor_get(x_2, 1);
-x_23 = lean_ctor_get(x_2, 2);
-x_24 = lean_ctor_get(x_2, 3);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_22 = lean_ctor_get(x_2, 0);
+x_23 = lean_ctor_get(x_2, 1);
+x_24 = lean_ctor_get(x_2, 2);
+x_25 = lean_ctor_get(x_2, 3);
+lean_inc(x_25);
 lean_inc(x_24);
 lean_inc(x_23);
 lean_inc(x_22);
-lean_inc(x_21);
 lean_dec(x_2);
-x_25 = lean_string_dec_lt(x_1, x_22);
-if (x_25 == 0)
-{
-uint8_t x_26; 
-x_26 = lean_string_dec_lt(x_22, x_1);
+x_26 = lean_string_dec_lt(x_1, x_23);
 if (x_26 == 0)
 {
-lean_object* x_27; 
+uint8_t x_27; 
+x_27 = lean_string_dec_lt(x_23, x_1);
+if (x_27 == 0)
+{
+lean_object* x_28; 
+lean_dec(x_24);
 lean_dec(x_23);
-lean_dec(x_22);
-x_27 = l_Std_RBNode_appendTrees___main___rarg(x_21, x_24);
-return x_27;
+x_28 = l_Std_RBNode_appendTrees___rarg(x_22, x_25);
+return x_28;
 }
 else
 {
-uint8_t x_28; 
-x_28 = l_Std_RBNode_isBlack___rarg(x_24);
-if (x_28 == 0)
+uint8_t x_29; 
+x_29 = l_Std_RBNode_isBlack___rarg(x_25);
+if (x_29 == 0)
 {
-lean_object* x_29; uint8_t x_30; lean_object* x_31; 
-x_29 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_24);
-x_30 = 0;
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_21);
-lean_ctor_set(x_31, 1, x_22);
-lean_ctor_set(x_31, 2, x_23);
-lean_ctor_set(x_31, 3, x_29);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_30);
-return x_31;
+lean_object* x_30; uint8_t x_31; lean_object* x_32; 
+x_30 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_25);
+x_31 = 0;
+x_32 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_32, 0, x_22);
+lean_ctor_set(x_32, 1, x_23);
+lean_ctor_set(x_32, 2, x_24);
+lean_ctor_set(x_32, 3, x_30);
+lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31);
+return x_32;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; 
-x_32 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_24);
-x_33 = l_Std_RBNode_balRight___rarg(x_21, x_22, x_23, x_32);
-return x_33;
+lean_object* x_33; lean_object* x_34; 
+x_33 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_25);
+x_34 = l_Std_RBNode_balRight___rarg(x_22, x_23, x_24, x_33);
+return x_34;
 }
 }
 }
 else
 {
-uint8_t x_34; 
-x_34 = l_Std_RBNode_isBlack___rarg(x_21);
-if (x_34 == 0)
+uint8_t x_35; 
+x_35 = l_Std_RBNode_isBlack___rarg(x_22);
+if (x_35 == 0)
 {
-lean_object* x_35; uint8_t x_36; lean_object* x_37; 
-x_35 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_21);
-x_36 = 0;
-x_37 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_37, 0, x_35);
-lean_ctor_set(x_37, 1, x_22);
-lean_ctor_set(x_37, 2, x_23);
-lean_ctor_set(x_37, 3, x_24);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
-return x_37;
+lean_object* x_36; uint8_t x_37; lean_object* x_38; 
+x_36 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_22);
+x_37 = 0;
+x_38 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_23);
+lean_ctor_set(x_38, 2, x_24);
+lean_ctor_set(x_38, 3, x_25);
+lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_37);
+return x_38;
 }
 else
 {
-lean_object* x_38; lean_object* x_39; 
-x_38 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_21);
-x_39 = l_Std_RBNode_balLeft___rarg(x_38, x_22, x_23, x_24);
-return x_39;
+lean_object* x_39; lean_object* x_40; 
+x_39 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_22);
+x_40 = l_Std_RBNode_balLeft___rarg(x_39, x_23, x_24, x_25);
+return x_40;
 }
 }
 }
@@ -4926,7 +5005,7 @@ lean_object* l_Std_RBNode_erase___at_Lean_Server_handleDidClose___spec__1(lean_o
 _start:
 {
 lean_object* x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_2);
 x_4 = l_Std_RBNode_setBlack___rarg(x_3);
 return x_4;
 }
@@ -4964,11 +5043,11 @@ return x_13;
 }
 }
 }
-lean_object* l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_del___main___at_Lean_Server_handleDidClose___spec__2(x_1, x_2);
+x_3 = l_Std_RBNode_del___at_Lean_Server_handleDidClose___spec__2(x_1, x_2);
 lean_dec(x_1);
 return x_3;
 }
diff --git a/stage0/stdlib/Lean/Syntax.c b/stage0/stdlib/Lean/Syntax.c
index f5df0661df..7500151c75 100644
--- a/stage0/stdlib/Lean/Syntax.c
+++ b/stage0/stdlib/Lean/Syntax.c
@@ -171,7 +171,6 @@ uint8_t l_Lean_Syntax_isAntiquot(lean_object*);
 lean_object* l_Lean_Syntax_ifNode___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_asNode___boxed(lean_object*);
 uint8_t l_List_beq___main___at_Lean_Syntax_structEq___main___spec__3(lean_object*, lean_object*);
-lean_object* l_Lean_Name_replacePrefix___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Array_back___at_Lean_Syntax_Traverser_up___spec__2___boxed(lean_object*);
 lean_object* l_Lean_SyntaxNode_getNumArgs___boxed(lean_object*);
 lean_object* l_Lean_Syntax_updateTrailing___main(lean_object*, lean_object*);
@@ -278,6 +277,7 @@ lean_object* l_Lean_Syntax_modifyArgs(lean_object*, lean_object*);
 lean_object* l_Lean_mkNode(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_isQuot___closed__1;
 lean_object* l_Lean_Syntax_getTailInfo___main(lean_object*);
+lean_object* l_Lean_Name_replacePrefix(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SyntaxNode_getArg(lean_object*, lean_object*);
 lean_object* l_Lean_Format_joinSep___main___at_Lean_Syntax_formatStxAux___main___spec__2___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Syntax_formatStxAux___main___closed__7;
@@ -4278,7 +4278,7 @@ if (x_11 == 0)
 lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; 
 x_12 = l_Lean_mkAppStx___closed__4;
 x_13 = lean_box(0);
-x_14 = l_Lean_Name_replacePrefix___main(x_6, x_12, x_13);
+x_14 = l_Lean_Name_replacePrefix(x_6, x_12, x_13);
 x_15 = l_System_FilePath_dirName___closed__1;
 x_16 = l_Lean_Name_toStringWithSep___main(x_15, x_14);
 x_17 = lean_alloc_ctor(2, 1, 0);
diff --git a/stage0/stdlib/Lean/Util/FindExpr.c b/stage0/stdlib/Lean/Util/FindExpr.c
index 1d1ee8562b..5cbad13b46 100644
--- a/stage0/stdlib/Lean/Util/FindExpr.c
+++ b/stage0/stdlib/Lean/Util/FindExpr.c
@@ -18,24 +18,27 @@ lean_object* lean_array_uget(lean_object*, size_t);
 lean_object* lean_array_uset(lean_object*, size_t, lean_object*);
 size_t l_Lean_Expr_FindImpl_cacheSize;
 lean_object* l_Lean_Expr_FindImpl_findM_x3f(lean_object*, size_t, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_occurs___lambda__1___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_FindImpl_findUnsafe_x3f(lean_object*, lean_object*);
+uint8_t l_Lean_Expr_occurs___lambda__1(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_find_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_FindImpl_initCache___closed__1;
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit_match__1(lean_object*);
 lean_object* l_Lean_Expr_occurs___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_find_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 size_t l_USize_mod(size_t, size_t);
 lean_object* l_Lean_Expr_FindImpl_visited(lean_object*, size_t, lean_object*);
 lean_object* l_Lean_Expr_FindImpl_initCache;
 size_t lean_ptr_addr(lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_expr_eqv(lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_FindImpl_visited___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_find_x3f_match__1(lean_object*);
 lean_object* lean_mk_array(lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(lean_object*, size_t, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main(lean_object*, size_t, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object*, size_t, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_FindImpl_findM_x3f___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_occurs(lean_object*, lean_object*);
-lean_object* l_Lean_Expr_find_x3f___main(lean_object*, lean_object*);
 static size_t _init_l_Lean_Expr_FindImpl_cacheSize() {
 _start:
 {
@@ -88,494 +91,1011 @@ x_5 = l_Lean_Expr_FindImpl_visited(x_1, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
 _start:
 {
-uint8_t x_5; lean_object* x_6; size_t x_98; size_t x_99; lean_object* x_100; size_t x_101; uint8_t x_102; 
-x_98 = lean_ptr_addr(x_3);
-x_99 = x_2 == 0 ? 0 : x_98 % x_2;
-x_100 = lean_array_uget(x_4, x_99);
-x_101 = lean_ptr_addr(x_100);
-lean_dec(x_100);
-x_102 = x_101 == x_98;
-if (x_102 == 0)
+switch (lean_obj_tag(x_1)) {
+case 5:
 {
-lean_object* x_103; uint8_t x_104; 
+lean_object* x_9; lean_object* x_10; uint64_t x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_12 = lean_box_uint64(x_11);
+x_13 = lean_apply_3(x_6, x_9, x_10, x_12);
+return x_13;
+}
+case 6:
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; uint64_t x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_1, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 2);
+lean_inc(x_16);
+x_17 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_18 = lean_box_uint64(x_17);
+x_19 = lean_apply_4(x_3, x_14, x_15, x_16, x_18);
+return x_19;
+}
+case 7:
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; uint64_t x_23; lean_object* x_24; lean_object* x_25; 
+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_20 = lean_ctor_get(x_1, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_1, 1);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_1, 2);
+lean_inc(x_22);
+x_23 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_24 = lean_box_uint64(x_23);
+x_25 = lean_apply_4(x_2, x_20, x_21, x_22, x_24);
+return x_25;
+}
+case 8:
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint64_t x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_26 = lean_ctor_get(x_1, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_1, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_1, 2);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_1, 3);
+lean_inc(x_29);
+x_30 = lean_ctor_get_uint64(x_1, sizeof(void*)*4);
+lean_dec(x_1);
+x_31 = lean_box_uint64(x_30);
+x_32 = lean_apply_5(x_5, x_26, x_27, x_28, x_29, x_31);
+return x_32;
+}
+case 10:
+{
+lean_object* x_33; lean_object* x_34; uint64_t x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_33 = lean_ctor_get(x_1, 0);
+lean_inc(x_33);
+x_34 = lean_ctor_get(x_1, 1);
+lean_inc(x_34);
+x_35 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_36 = lean_box_uint64(x_35);
+x_37 = lean_apply_3(x_4, x_33, x_34, x_36);
+return x_37;
+}
+case 11:
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; uint64_t x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_38 = lean_ctor_get(x_1, 0);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_1, 1);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_1, 2);
+lean_inc(x_40);
+x_41 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_42 = lean_box_uint64(x_41);
+x_43 = lean_apply_4(x_7, x_38, x_39, x_40, x_42);
+return x_43;
+}
+default: 
+{
+lean_object* x_44; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_44 = lean_apply_1(x_8, x_1);
+return x_44;
+}
+}
+}
+}
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_FindImpl_findM_x3f_visit_match__1___rarg), 8, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; uint8_t x_7; 
 lean_inc(x_3);
-x_103 = lean_array_uset(x_4, x_99, x_3);
-x_104 = 0;
-x_5 = x_104;
-x_6 = x_103;
-goto block_97;
-}
-else
+x_5 = l_Lean_Expr_FindImpl_visited(x_3, x_2, x_4);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+x_7 = lean_unbox(x_6);
+lean_dec(x_6);
+if (x_7 == 0)
 {
-uint8_t x_105; 
-x_105 = 1;
-x_5 = x_105;
-x_6 = x_4;
-goto block_97;
-}
-block_97:
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_5);
+if (x_8 == 0)
 {
-if (x_5 == 0)
-{
-lean_object* x_7; uint8_t x_8; 
+lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; 
+x_9 = lean_ctor_get(x_5, 1);
+x_10 = lean_ctor_get(x_5, 0);
+lean_dec(x_10);
 lean_inc(x_1);
 lean_inc(x_3);
-x_7 = lean_apply_1(x_1, x_3);
-x_8 = lean_unbox(x_7);
-lean_dec(x_7);
-if (x_8 == 0)
+x_11 = lean_apply_1(x_1, x_3);
+x_12 = lean_unbox(x_11);
+lean_dec(x_11);
+if (x_12 == 0)
 {
 switch (lean_obj_tag(x_3)) {
 case 5:
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_9 = lean_ctor_get(x_3, 0);
-lean_inc(x_9);
-x_10 = lean_ctor_get(x_3, 1);
-lean_inc(x_10);
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_free_object(x_5);
+x_13 = lean_ctor_get(x_3, 0);
+lean_inc(x_13);
+x_14 = lean_ctor_get(x_3, 1);
+lean_inc(x_14);
 lean_dec(x_3);
 lean_inc(x_1);
-x_11 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_2, x_9, x_6);
-x_12 = lean_ctor_get(x_11, 0);
-lean_inc(x_12);
-if (lean_obj_tag(x_12) == 0)
+x_15 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_13, x_9);
+x_16 = lean_ctor_get(x_15, 0);
+lean_inc(x_16);
+if (lean_obj_tag(x_16) == 0)
 {
-lean_object* x_13; 
-x_13 = lean_ctor_get(x_11, 1);
-lean_inc(x_13);
-lean_dec(x_11);
-x_3 = x_10;
-x_4 = x_13;
+lean_object* x_17; 
+x_17 = lean_ctor_get(x_15, 1);
+lean_inc(x_17);
+lean_dec(x_15);
+x_3 = x_14;
+x_4 = x_17;
 goto _start;
 }
 else
 {
-uint8_t x_15; 
-lean_dec(x_10);
+uint8_t x_19; 
+lean_dec(x_14);
 lean_dec(x_1);
-x_15 = !lean_is_exclusive(x_11);
-if (x_15 == 0)
+x_19 = !lean_is_exclusive(x_15);
+if (x_19 == 0)
 {
-lean_object* x_16; uint8_t x_17; 
-x_16 = lean_ctor_get(x_11, 0);
+lean_object* x_20; uint8_t x_21; 
+x_20 = lean_ctor_get(x_15, 0);
+lean_dec(x_20);
+x_21 = !lean_is_exclusive(x_16);
+if (x_21 == 0)
+{
+return x_15;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; 
+x_22 = lean_ctor_get(x_16, 0);
+lean_inc(x_22);
 lean_dec(x_16);
-x_17 = !lean_is_exclusive(x_12);
-if (x_17 == 0)
-{
-return x_11;
-}
-else
-{
-lean_object* x_18; lean_object* x_19; 
-x_18 = lean_ctor_get(x_12, 0);
-lean_inc(x_18);
-lean_dec(x_12);
-x_19 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_19, 0, x_18);
-lean_ctor_set(x_11, 0, x_19);
-return x_11;
+x_23 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_23, 0, x_22);
+lean_ctor_set(x_15, 0, x_23);
+return x_15;
 }
 }
 else
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
-x_20 = lean_ctor_get(x_11, 1);
-lean_inc(x_20);
-lean_dec(x_11);
-x_21 = lean_ctor_get(x_12, 0);
-lean_inc(x_21);
-if (lean_is_exclusive(x_12)) {
- lean_ctor_release(x_12, 0);
- x_22 = x_12;
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+x_24 = lean_ctor_get(x_15, 1);
+lean_inc(x_24);
+lean_dec(x_15);
+x_25 = lean_ctor_get(x_16, 0);
+lean_inc(x_25);
+if (lean_is_exclusive(x_16)) {
+ lean_ctor_release(x_16, 0);
+ x_26 = x_16;
 } else {
- lean_dec_ref(x_12);
- x_22 = lean_box(0);
+ lean_dec_ref(x_16);
+ x_26 = lean_box(0);
 }
-if (lean_is_scalar(x_22)) {
- x_23 = lean_alloc_ctor(1, 1, 0);
+if (lean_is_scalar(x_26)) {
+ x_27 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_23 = x_22;
+ x_27 = x_26;
 }
-lean_ctor_set(x_23, 0, x_21);
-x_24 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_24, 0, x_23);
-lean_ctor_set(x_24, 1, x_20);
-return x_24;
+lean_ctor_set(x_27, 0, x_25);
+x_28 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_28, 0, x_27);
+lean_ctor_set(x_28, 1, x_24);
+return x_28;
 }
 }
 }
 case 6:
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_25 = lean_ctor_get(x_3, 1);
-lean_inc(x_25);
-x_26 = lean_ctor_get(x_3, 2);
-lean_inc(x_26);
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+lean_free_object(x_5);
+x_29 = lean_ctor_get(x_3, 1);
+lean_inc(x_29);
+x_30 = lean_ctor_get(x_3, 2);
+lean_inc(x_30);
 lean_dec(x_3);
 lean_inc(x_1);
-x_27 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_2, x_25, x_6);
-x_28 = lean_ctor_get(x_27, 0);
-lean_inc(x_28);
-if (lean_obj_tag(x_28) == 0)
+x_31 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_29, x_9);
+x_32 = lean_ctor_get(x_31, 0);
+lean_inc(x_32);
+if (lean_obj_tag(x_32) == 0)
 {
-lean_object* x_29; 
-x_29 = lean_ctor_get(x_27, 1);
-lean_inc(x_29);
-lean_dec(x_27);
-x_3 = x_26;
-x_4 = x_29;
+lean_object* x_33; 
+x_33 = lean_ctor_get(x_31, 1);
+lean_inc(x_33);
+lean_dec(x_31);
+x_3 = x_30;
+x_4 = x_33;
 goto _start;
 }
 else
 {
-uint8_t x_31; 
-lean_dec(x_26);
+uint8_t x_35; 
+lean_dec(x_30);
 lean_dec(x_1);
-x_31 = !lean_is_exclusive(x_27);
-if (x_31 == 0)
+x_35 = !lean_is_exclusive(x_31);
+if (x_35 == 0)
 {
-lean_object* x_32; uint8_t x_33; 
-x_32 = lean_ctor_get(x_27, 0);
+lean_object* x_36; uint8_t x_37; 
+x_36 = lean_ctor_get(x_31, 0);
+lean_dec(x_36);
+x_37 = !lean_is_exclusive(x_32);
+if (x_37 == 0)
+{
+return x_31;
+}
+else
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = lean_ctor_get(x_32, 0);
+lean_inc(x_38);
 lean_dec(x_32);
-x_33 = !lean_is_exclusive(x_28);
-if (x_33 == 0)
-{
-return x_27;
-}
-else
-{
-lean_object* x_34; lean_object* x_35; 
-x_34 = lean_ctor_get(x_28, 0);
-lean_inc(x_34);
-lean_dec(x_28);
-x_35 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_35, 0, x_34);
-lean_ctor_set(x_27, 0, x_35);
-return x_27;
+x_39 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_39, 0, x_38);
+lean_ctor_set(x_31, 0, x_39);
+return x_31;
 }
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
-x_36 = lean_ctor_get(x_27, 1);
-lean_inc(x_36);
-lean_dec(x_27);
-x_37 = lean_ctor_get(x_28, 0);
-lean_inc(x_37);
-if (lean_is_exclusive(x_28)) {
- lean_ctor_release(x_28, 0);
- x_38 = x_28;
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
+x_40 = lean_ctor_get(x_31, 1);
+lean_inc(x_40);
+lean_dec(x_31);
+x_41 = lean_ctor_get(x_32, 0);
+lean_inc(x_41);
+if (lean_is_exclusive(x_32)) {
+ lean_ctor_release(x_32, 0);
+ x_42 = x_32;
 } else {
- lean_dec_ref(x_28);
- x_38 = lean_box(0);
+ lean_dec_ref(x_32);
+ x_42 = lean_box(0);
 }
-if (lean_is_scalar(x_38)) {
- x_39 = lean_alloc_ctor(1, 1, 0);
+if (lean_is_scalar(x_42)) {
+ x_43 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_39 = x_38;
+ x_43 = x_42;
 }
-lean_ctor_set(x_39, 0, x_37);
-x_40 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_40, 0, x_39);
-lean_ctor_set(x_40, 1, x_36);
-return x_40;
+lean_ctor_set(x_43, 0, x_41);
+x_44 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_44, 0, x_43);
+lean_ctor_set(x_44, 1, x_40);
+return x_44;
 }
 }
 }
 case 7:
 {
-lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; 
-x_41 = lean_ctor_get(x_3, 1);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_3, 2);
-lean_inc(x_42);
+lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_free_object(x_5);
+x_45 = lean_ctor_get(x_3, 1);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_3, 2);
+lean_inc(x_46);
 lean_dec(x_3);
 lean_inc(x_1);
-x_43 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_2, x_41, x_6);
-x_44 = lean_ctor_get(x_43, 0);
-lean_inc(x_44);
-if (lean_obj_tag(x_44) == 0)
+x_47 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_45, x_9);
+x_48 = lean_ctor_get(x_47, 0);
+lean_inc(x_48);
+if (lean_obj_tag(x_48) == 0)
 {
-lean_object* x_45; 
-x_45 = lean_ctor_get(x_43, 1);
-lean_inc(x_45);
-lean_dec(x_43);
-x_3 = x_42;
-x_4 = x_45;
+lean_object* x_49; 
+x_49 = lean_ctor_get(x_47, 1);
+lean_inc(x_49);
+lean_dec(x_47);
+x_3 = x_46;
+x_4 = x_49;
 goto _start;
 }
 else
 {
-uint8_t x_47; 
-lean_dec(x_42);
+uint8_t x_51; 
+lean_dec(x_46);
 lean_dec(x_1);
-x_47 = !lean_is_exclusive(x_43);
-if (x_47 == 0)
+x_51 = !lean_is_exclusive(x_47);
+if (x_51 == 0)
 {
-lean_object* x_48; uint8_t x_49; 
-x_48 = lean_ctor_get(x_43, 0);
+lean_object* x_52; uint8_t x_53; 
+x_52 = lean_ctor_get(x_47, 0);
+lean_dec(x_52);
+x_53 = !lean_is_exclusive(x_48);
+if (x_53 == 0)
+{
+return x_47;
+}
+else
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = lean_ctor_get(x_48, 0);
+lean_inc(x_54);
 lean_dec(x_48);
-x_49 = !lean_is_exclusive(x_44);
-if (x_49 == 0)
-{
-return x_43;
-}
-else
-{
-lean_object* x_50; lean_object* x_51; 
-x_50 = lean_ctor_get(x_44, 0);
-lean_inc(x_50);
-lean_dec(x_44);
-x_51 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_51, 0, x_50);
-lean_ctor_set(x_43, 0, x_51);
-return x_43;
+x_55 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_55, 0, x_54);
+lean_ctor_set(x_47, 0, x_55);
+return x_47;
 }
 }
 else
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; 
-x_52 = lean_ctor_get(x_43, 1);
-lean_inc(x_52);
-lean_dec(x_43);
-x_53 = lean_ctor_get(x_44, 0);
-lean_inc(x_53);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- x_54 = x_44;
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_56 = lean_ctor_get(x_47, 1);
+lean_inc(x_56);
+lean_dec(x_47);
+x_57 = lean_ctor_get(x_48, 0);
+lean_inc(x_57);
+if (lean_is_exclusive(x_48)) {
+ lean_ctor_release(x_48, 0);
+ x_58 = x_48;
 } else {
- lean_dec_ref(x_44);
- x_54 = lean_box(0);
+ lean_dec_ref(x_48);
+ x_58 = lean_box(0);
 }
-if (lean_is_scalar(x_54)) {
- x_55 = lean_alloc_ctor(1, 1, 0);
+if (lean_is_scalar(x_58)) {
+ x_59 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_55 = x_54;
+ x_59 = x_58;
 }
-lean_ctor_set(x_55, 0, x_53);
-x_56 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_56, 0, x_55);
-lean_ctor_set(x_56, 1, x_52);
-return x_56;
+lean_ctor_set(x_59, 0, x_57);
+x_60 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_60, 0, x_59);
+lean_ctor_set(x_60, 1, x_56);
+return x_60;
 }
 }
 }
 case 8:
 {
-lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; 
-x_57 = lean_ctor_get(x_3, 1);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_3, 2);
-lean_inc(x_58);
-x_59 = lean_ctor_get(x_3, 3);
-lean_inc(x_59);
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_free_object(x_5);
+x_61 = lean_ctor_get(x_3, 1);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_3, 2);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_3, 3);
+lean_inc(x_63);
 lean_dec(x_3);
 lean_inc(x_1);
-x_60 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_2, x_57, x_6);
-x_61 = lean_ctor_get(x_60, 0);
-lean_inc(x_61);
-if (lean_obj_tag(x_61) == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; 
-x_62 = lean_ctor_get(x_60, 1);
-lean_inc(x_62);
-lean_dec(x_60);
-lean_inc(x_1);
-x_63 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_2, x_58, x_62);
-x_64 = lean_ctor_get(x_63, 0);
-lean_inc(x_64);
-if (lean_obj_tag(x_64) == 0)
-{
-lean_object* x_65; 
-x_65 = lean_ctor_get(x_63, 1);
+x_64 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_61, x_9);
+x_65 = lean_ctor_get(x_64, 0);
 lean_inc(x_65);
-lean_dec(x_63);
-x_3 = x_59;
-x_4 = x_65;
+if (lean_obj_tag(x_65) == 0)
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; 
+x_66 = lean_ctor_get(x_64, 1);
+lean_inc(x_66);
+lean_dec(x_64);
+lean_inc(x_1);
+x_67 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_62, x_66);
+x_68 = lean_ctor_get(x_67, 0);
+lean_inc(x_68);
+if (lean_obj_tag(x_68) == 0)
+{
+lean_object* x_69; 
+x_69 = lean_ctor_get(x_67, 1);
+lean_inc(x_69);
+lean_dec(x_67);
+x_3 = x_63;
+x_4 = x_69;
 goto _start;
 }
 else
 {
-uint8_t x_67; 
-lean_dec(x_59);
-lean_dec(x_1);
-x_67 = !lean_is_exclusive(x_63);
-if (x_67 == 0)
-{
-lean_object* x_68; uint8_t x_69; 
-x_68 = lean_ctor_get(x_63, 0);
-lean_dec(x_68);
-x_69 = !lean_is_exclusive(x_64);
-if (x_69 == 0)
-{
-return x_63;
-}
-else
-{
-lean_object* x_70; lean_object* x_71; 
-x_70 = lean_ctor_get(x_64, 0);
-lean_inc(x_70);
-lean_dec(x_64);
-x_71 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_63, 0, x_71);
-return x_63;
-}
-}
-else
-{
-lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; 
-x_72 = lean_ctor_get(x_63, 1);
-lean_inc(x_72);
+uint8_t x_71; 
 lean_dec(x_63);
-x_73 = lean_ctor_get(x_64, 0);
-lean_inc(x_73);
-if (lean_is_exclusive(x_64)) {
- lean_ctor_release(x_64, 0);
- x_74 = x_64;
-} else {
- lean_dec_ref(x_64);
- x_74 = lean_box(0);
-}
-if (lean_is_scalar(x_74)) {
- x_75 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_75 = x_74;
-}
-lean_ctor_set(x_75, 0, x_73);
-x_76 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_76, 0, x_75);
-lean_ctor_set(x_76, 1, x_72);
-return x_76;
-}
-}
-}
-else
-{
-uint8_t x_77; 
-lean_dec(x_59);
-lean_dec(x_58);
 lean_dec(x_1);
-x_77 = !lean_is_exclusive(x_60);
-if (x_77 == 0)
+x_71 = !lean_is_exclusive(x_67);
+if (x_71 == 0)
 {
-lean_object* x_78; uint8_t x_79; 
-x_78 = lean_ctor_get(x_60, 0);
-lean_dec(x_78);
-x_79 = !lean_is_exclusive(x_61);
-if (x_79 == 0)
+lean_object* x_72; uint8_t x_73; 
+x_72 = lean_ctor_get(x_67, 0);
+lean_dec(x_72);
+x_73 = !lean_is_exclusive(x_68);
+if (x_73 == 0)
 {
-return x_60;
+return x_67;
 }
 else
 {
-lean_object* x_80; lean_object* x_81; 
-x_80 = lean_ctor_get(x_61, 0);
-lean_inc(x_80);
-lean_dec(x_61);
-x_81 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_81, 0, x_80);
-lean_ctor_set(x_60, 0, x_81);
-return x_60;
+lean_object* x_74; lean_object* x_75; 
+x_74 = lean_ctor_get(x_68, 0);
+lean_inc(x_74);
+lean_dec(x_68);
+x_75 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_75, 0, x_74);
+lean_ctor_set(x_67, 0, x_75);
+return x_67;
 }
 }
 else
 {
-lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-x_82 = lean_ctor_get(x_60, 1);
-lean_inc(x_82);
-lean_dec(x_60);
-x_83 = lean_ctor_get(x_61, 0);
-lean_inc(x_83);
-if (lean_is_exclusive(x_61)) {
- lean_ctor_release(x_61, 0);
- x_84 = x_61;
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; 
+x_76 = lean_ctor_get(x_67, 1);
+lean_inc(x_76);
+lean_dec(x_67);
+x_77 = lean_ctor_get(x_68, 0);
+lean_inc(x_77);
+if (lean_is_exclusive(x_68)) {
+ lean_ctor_release(x_68, 0);
+ x_78 = x_68;
 } else {
- lean_dec_ref(x_61);
- x_84 = lean_box(0);
+ lean_dec_ref(x_68);
+ x_78 = lean_box(0);
 }
-if (lean_is_scalar(x_84)) {
- x_85 = lean_alloc_ctor(1, 1, 0);
+if (lean_is_scalar(x_78)) {
+ x_79 = lean_alloc_ctor(1, 1, 0);
 } else {
- x_85 = x_84;
+ x_79 = x_78;
 }
-lean_ctor_set(x_85, 0, x_83);
-x_86 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_86, 0, x_85);
-lean_ctor_set(x_86, 1, x_82);
-return x_86;
+lean_ctor_set(x_79, 0, x_77);
+x_80 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_80, 0, x_79);
+lean_ctor_set(x_80, 1, x_76);
+return x_80;
+}
+}
+}
+else
+{
+uint8_t x_81; 
+lean_dec(x_63);
+lean_dec(x_62);
+lean_dec(x_1);
+x_81 = !lean_is_exclusive(x_64);
+if (x_81 == 0)
+{
+lean_object* x_82; uint8_t x_83; 
+x_82 = lean_ctor_get(x_64, 0);
+lean_dec(x_82);
+x_83 = !lean_is_exclusive(x_65);
+if (x_83 == 0)
+{
+return x_64;
+}
+else
+{
+lean_object* x_84; lean_object* x_85; 
+x_84 = lean_ctor_get(x_65, 0);
+lean_inc(x_84);
+lean_dec(x_65);
+x_85 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_85, 0, x_84);
+lean_ctor_set(x_64, 0, x_85);
+return x_64;
+}
+}
+else
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; 
+x_86 = lean_ctor_get(x_64, 1);
+lean_inc(x_86);
+lean_dec(x_64);
+x_87 = lean_ctor_get(x_65, 0);
+lean_inc(x_87);
+if (lean_is_exclusive(x_65)) {
+ lean_ctor_release(x_65, 0);
+ x_88 = x_65;
+} else {
+ lean_dec_ref(x_65);
+ x_88 = lean_box(0);
+}
+if (lean_is_scalar(x_88)) {
+ x_89 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_89 = x_88;
+}
+lean_ctor_set(x_89, 0, x_87);
+x_90 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_90, 0, x_89);
+lean_ctor_set(x_90, 1, x_86);
+return x_90;
 }
 }
 }
 case 10:
 {
-lean_object* x_87; 
-x_87 = lean_ctor_get(x_3, 1);
-lean_inc(x_87);
+lean_object* x_91; 
+lean_free_object(x_5);
+x_91 = lean_ctor_get(x_3, 1);
+lean_inc(x_91);
 lean_dec(x_3);
-x_3 = x_87;
-x_4 = x_6;
+x_3 = x_91;
+x_4 = x_9;
 goto _start;
 }
 case 11:
 {
-lean_object* x_89; 
-x_89 = lean_ctor_get(x_3, 2);
-lean_inc(x_89);
+lean_object* x_93; 
+lean_free_object(x_5);
+x_93 = lean_ctor_get(x_3, 2);
+lean_inc(x_93);
 lean_dec(x_3);
-x_3 = x_89;
-x_4 = x_6;
+x_3 = x_93;
+x_4 = x_9;
 goto _start;
 }
 default: 
 {
-lean_object* x_91; lean_object* x_92; 
-lean_dec(x_3);
-lean_dec(x_1);
-x_91 = lean_box(0);
-x_92 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_92, 0, x_91);
-lean_ctor_set(x_92, 1, x_6);
-return x_92;
-}
-}
-}
-else
-{
-lean_object* x_93; lean_object* x_94; 
-lean_dec(x_1);
-x_93 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_93, 0, x_3);
-x_94 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_94, 0, x_93);
-lean_ctor_set(x_94, 1, x_6);
-return x_94;
-}
-}
-else
-{
-lean_object* x_95; lean_object* x_96; 
+lean_object* x_95; 
 lean_dec(x_3);
 lean_dec(x_1);
 x_95 = lean_box(0);
-x_96 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_96, 0, x_95);
-lean_ctor_set(x_96, 1, x_6);
-return x_96;
+lean_ctor_set(x_5, 0, x_95);
+return x_5;
+}
+}
+}
+else
+{
+lean_object* x_96; 
+lean_dec(x_1);
+x_96 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_96, 0, x_3);
+lean_ctor_set(x_5, 0, x_96);
+return x_5;
+}
+}
+else
+{
+lean_object* x_97; lean_object* x_98; uint8_t x_99; 
+x_97 = lean_ctor_get(x_5, 1);
+lean_inc(x_97);
+lean_dec(x_5);
+lean_inc(x_1);
+lean_inc(x_3);
+x_98 = lean_apply_1(x_1, x_3);
+x_99 = lean_unbox(x_98);
+lean_dec(x_98);
+if (x_99 == 0)
+{
+switch (lean_obj_tag(x_3)) {
+case 5:
+{
+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);
+x_101 = lean_ctor_get(x_3, 1);
+lean_inc(x_101);
+lean_dec(x_3);
+lean_inc(x_1);
+x_102 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_100, x_97);
+x_103 = lean_ctor_get(x_102, 0);
+lean_inc(x_103);
+if (lean_obj_tag(x_103) == 0)
+{
+lean_object* x_104; 
+x_104 = lean_ctor_get(x_102, 1);
+lean_inc(x_104);
+lean_dec(x_102);
+x_3 = x_101;
+x_4 = x_104;
+goto _start;
+}
+else
+{
+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_dec(x_101);
+lean_dec(x_1);
+x_106 = lean_ctor_get(x_102, 1);
+lean_inc(x_106);
+if (lean_is_exclusive(x_102)) {
+ lean_ctor_release(x_102, 0);
+ lean_ctor_release(x_102, 1);
+ x_107 = x_102;
+} else {
+ lean_dec_ref(x_102);
+ x_107 = lean_box(0);
+}
+x_108 = lean_ctor_get(x_103, 0);
+lean_inc(x_108);
+if (lean_is_exclusive(x_103)) {
+ lean_ctor_release(x_103, 0);
+ x_109 = x_103;
+} else {
+ lean_dec_ref(x_103);
+ x_109 = lean_box(0);
+}
+if (lean_is_scalar(x_109)) {
+ x_110 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_110 = x_109;
+}
+lean_ctor_set(x_110, 0, x_108);
+if (lean_is_scalar(x_107)) {
+ x_111 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_111 = x_107;
+}
+lean_ctor_set(x_111, 0, x_110);
+lean_ctor_set(x_111, 1, x_106);
+return x_111;
+}
+}
+case 6:
+{
+lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; 
+x_112 = lean_ctor_get(x_3, 1);
+lean_inc(x_112);
+x_113 = lean_ctor_get(x_3, 2);
+lean_inc(x_113);
+lean_dec(x_3);
+lean_inc(x_1);
+x_114 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_112, x_97);
+x_115 = lean_ctor_get(x_114, 0);
+lean_inc(x_115);
+if (lean_obj_tag(x_115) == 0)
+{
+lean_object* x_116; 
+x_116 = lean_ctor_get(x_114, 1);
+lean_inc(x_116);
+lean_dec(x_114);
+x_3 = x_113;
+x_4 = x_116;
+goto _start;
+}
+else
+{
+lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; 
+lean_dec(x_113);
+lean_dec(x_1);
+x_118 = lean_ctor_get(x_114, 1);
+lean_inc(x_118);
+if (lean_is_exclusive(x_114)) {
+ lean_ctor_release(x_114, 0);
+ lean_ctor_release(x_114, 1);
+ x_119 = x_114;
+} else {
+ lean_dec_ref(x_114);
+ x_119 = lean_box(0);
+}
+x_120 = lean_ctor_get(x_115, 0);
+lean_inc(x_120);
+if (lean_is_exclusive(x_115)) {
+ lean_ctor_release(x_115, 0);
+ x_121 = x_115;
+} else {
+ lean_dec_ref(x_115);
+ x_121 = lean_box(0);
+}
+if (lean_is_scalar(x_121)) {
+ x_122 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_122 = x_121;
+}
+lean_ctor_set(x_122, 0, x_120);
+if (lean_is_scalar(x_119)) {
+ x_123 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_123 = x_119;
+}
+lean_ctor_set(x_123, 0, x_122);
+lean_ctor_set(x_123, 1, x_118);
+return x_123;
+}
+}
+case 7:
+{
+lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; 
+x_124 = lean_ctor_get(x_3, 1);
+lean_inc(x_124);
+x_125 = lean_ctor_get(x_3, 2);
+lean_inc(x_125);
+lean_dec(x_3);
+lean_inc(x_1);
+x_126 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_124, x_97);
+x_127 = lean_ctor_get(x_126, 0);
+lean_inc(x_127);
+if (lean_obj_tag(x_127) == 0)
+{
+lean_object* x_128; 
+x_128 = lean_ctor_get(x_126, 1);
+lean_inc(x_128);
+lean_dec(x_126);
+x_3 = x_125;
+x_4 = x_128;
+goto _start;
+}
+else
+{
+lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; 
+lean_dec(x_125);
+lean_dec(x_1);
+x_130 = lean_ctor_get(x_126, 1);
+lean_inc(x_130);
+if (lean_is_exclusive(x_126)) {
+ lean_ctor_release(x_126, 0);
+ lean_ctor_release(x_126, 1);
+ x_131 = x_126;
+} else {
+ lean_dec_ref(x_126);
+ x_131 = lean_box(0);
+}
+x_132 = lean_ctor_get(x_127, 0);
+lean_inc(x_132);
+if (lean_is_exclusive(x_127)) {
+ lean_ctor_release(x_127, 0);
+ x_133 = x_127;
+} else {
+ lean_dec_ref(x_127);
+ x_133 = lean_box(0);
+}
+if (lean_is_scalar(x_133)) {
+ x_134 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_134 = x_133;
+}
+lean_ctor_set(x_134, 0, x_132);
+if (lean_is_scalar(x_131)) {
+ x_135 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_135 = x_131;
+}
+lean_ctor_set(x_135, 0, x_134);
+lean_ctor_set(x_135, 1, x_130);
+return x_135;
+}
+}
+case 8:
+{
+lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
+x_136 = lean_ctor_get(x_3, 1);
+lean_inc(x_136);
+x_137 = lean_ctor_get(x_3, 2);
+lean_inc(x_137);
+x_138 = lean_ctor_get(x_3, 3);
+lean_inc(x_138);
+lean_dec(x_3);
+lean_inc(x_1);
+x_139 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_136, x_97);
+x_140 = lean_ctor_get(x_139, 0);
+lean_inc(x_140);
+if (lean_obj_tag(x_140) == 0)
+{
+lean_object* x_141; lean_object* x_142; lean_object* x_143; 
+x_141 = lean_ctor_get(x_139, 1);
+lean_inc(x_141);
+lean_dec(x_139);
+lean_inc(x_1);
+x_142 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_137, x_141);
+x_143 = lean_ctor_get(x_142, 0);
+lean_inc(x_143);
+if (lean_obj_tag(x_143) == 0)
+{
+lean_object* x_144; 
+x_144 = lean_ctor_get(x_142, 1);
+lean_inc(x_144);
+lean_dec(x_142);
+x_3 = x_138;
+x_4 = x_144;
+goto _start;
+}
+else
+{
+lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; 
+lean_dec(x_138);
+lean_dec(x_1);
+x_146 = lean_ctor_get(x_142, 1);
+lean_inc(x_146);
+if (lean_is_exclusive(x_142)) {
+ lean_ctor_release(x_142, 0);
+ lean_ctor_release(x_142, 1);
+ x_147 = x_142;
+} else {
+ lean_dec_ref(x_142);
+ x_147 = lean_box(0);
+}
+x_148 = lean_ctor_get(x_143, 0);
+lean_inc(x_148);
+if (lean_is_exclusive(x_143)) {
+ lean_ctor_release(x_143, 0);
+ x_149 = x_143;
+} else {
+ lean_dec_ref(x_143);
+ x_149 = lean_box(0);
+}
+if (lean_is_scalar(x_149)) {
+ x_150 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_150 = x_149;
+}
+lean_ctor_set(x_150, 0, x_148);
+if (lean_is_scalar(x_147)) {
+ x_151 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_151 = x_147;
+}
+lean_ctor_set(x_151, 0, x_150);
+lean_ctor_set(x_151, 1, x_146);
+return x_151;
+}
+}
+else
+{
+lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; 
+lean_dec(x_138);
+lean_dec(x_137);
+lean_dec(x_1);
+x_152 = lean_ctor_get(x_139, 1);
+lean_inc(x_152);
+if (lean_is_exclusive(x_139)) {
+ lean_ctor_release(x_139, 0);
+ lean_ctor_release(x_139, 1);
+ x_153 = x_139;
+} else {
+ lean_dec_ref(x_139);
+ x_153 = lean_box(0);
+}
+x_154 = lean_ctor_get(x_140, 0);
+lean_inc(x_154);
+if (lean_is_exclusive(x_140)) {
+ lean_ctor_release(x_140, 0);
+ x_155 = x_140;
+} else {
+ lean_dec_ref(x_140);
+ x_155 = lean_box(0);
+}
+if (lean_is_scalar(x_155)) {
+ x_156 = lean_alloc_ctor(1, 1, 0);
+} else {
+ x_156 = x_155;
+}
+lean_ctor_set(x_156, 0, x_154);
+if (lean_is_scalar(x_153)) {
+ x_157 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_157 = x_153;
+}
+lean_ctor_set(x_157, 0, x_156);
+lean_ctor_set(x_157, 1, x_152);
+return x_157;
+}
+}
+case 10:
+{
+lean_object* x_158; 
+x_158 = lean_ctor_get(x_3, 1);
+lean_inc(x_158);
+lean_dec(x_3);
+x_3 = x_158;
+x_4 = x_97;
+goto _start;
+}
+case 11:
+{
+lean_object* x_160; 
+x_160 = lean_ctor_get(x_3, 2);
+lean_inc(x_160);
+lean_dec(x_3);
+x_3 = x_160;
+x_4 = x_97;
+goto _start;
+}
+default: 
+{
+lean_object* x_162; lean_object* x_163; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_162 = lean_box(0);
+x_163 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_163, 0, x_162);
+lean_ctor_set(x_163, 1, x_97);
+return x_163;
+}
+}
+}
+else
+{
+lean_object* x_164; lean_object* x_165; 
+lean_dec(x_1);
+x_164 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_164, 0, x_3);
+x_165 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_165, 0, x_164);
+lean_ctor_set(x_165, 1, x_97);
+return x_165;
+}
+}
+}
+else
+{
+uint8_t x_166; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_166 = !lean_is_exclusive(x_5);
+if (x_166 == 0)
+{
+lean_object* x_167; lean_object* x_168; 
+x_167 = lean_ctor_get(x_5, 0);
+lean_dec(x_167);
+x_168 = lean_box(0);
+lean_ctor_set(x_5, 0, x_168);
+return x_5;
+}
+else
+{
+lean_object* x_169; lean_object* x_170; lean_object* x_171; 
+x_169 = lean_ctor_get(x_5, 1);
+lean_inc(x_169);
+lean_dec(x_5);
+x_170 = lean_box(0);
+x_171 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_171, 0, x_170);
+lean_ctor_set(x_171, 1, x_169);
+return x_171;
 }
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Expr_FindImpl_findM_x3f_visit___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 size_t x_5; lean_object* x_6; 
 x_5 = lean_unbox_usize(x_2);
 lean_dec(x_2);
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_5, x_3, x_4);
+x_6 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_5, x_3, x_4);
 return x_6;
 }
 }
@@ -583,7 +1103,7 @@ lean_object* l_Lean_Expr_FindImpl_findM_x3f(lean_object* x_1, size_t x_2, lean_o
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_2, x_3, x_4);
+x_5 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_2, x_3, x_4);
 return x_5;
 }
 }
@@ -621,14 +1141,165 @@ _start:
 size_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_3 = 8192;
 x_4 = l_Lean_Expr_FindImpl_initCache;
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main(x_1, x_3, x_2, x_4);
+x_5 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_1, x_3, x_2, x_4);
 x_6 = lean_ctor_get(x_5, 0);
 lean_inc(x_6);
 lean_dec(x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_Expr_find_x3f___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Expr_find_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 5:
+{
+lean_object* x_9; lean_object* x_10; uint64_t x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_12 = lean_box_uint64(x_11);
+x_13 = lean_apply_3(x_6, x_9, x_10, x_12);
+return x_13;
+}
+case 6:
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; uint64_t x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_1, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 2);
+lean_inc(x_16);
+x_17 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_18 = lean_box_uint64(x_17);
+x_19 = lean_apply_4(x_3, x_14, x_15, x_16, x_18);
+return x_19;
+}
+case 7:
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; uint64_t x_23; lean_object* x_24; lean_object* x_25; 
+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_20 = lean_ctor_get(x_1, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_1, 1);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_1, 2);
+lean_inc(x_22);
+x_23 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_24 = lean_box_uint64(x_23);
+x_25 = lean_apply_4(x_2, x_20, x_21, x_22, x_24);
+return x_25;
+}
+case 8:
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint64_t x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_26 = lean_ctor_get(x_1, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_1, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_1, 2);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_1, 3);
+lean_inc(x_29);
+x_30 = lean_ctor_get_uint64(x_1, sizeof(void*)*4);
+lean_dec(x_1);
+x_31 = lean_box_uint64(x_30);
+x_32 = lean_apply_5(x_5, x_26, x_27, x_28, x_29, x_31);
+return x_32;
+}
+case 10:
+{
+lean_object* x_33; lean_object* x_34; uint64_t x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_33 = lean_ctor_get(x_1, 0);
+lean_inc(x_33);
+x_34 = lean_ctor_get(x_1, 1);
+lean_inc(x_34);
+x_35 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_36 = lean_box_uint64(x_35);
+x_37 = lean_apply_3(x_4, x_33, x_34, x_36);
+return x_37;
+}
+case 11:
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; uint64_t x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_38 = lean_ctor_get(x_1, 0);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_1, 1);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_1, 2);
+lean_inc(x_40);
+x_41 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_42 = lean_box_uint64(x_41);
+x_43 = lean_apply_4(x_7, x_38, x_39, x_40, x_42);
+return x_43;
+}
+default: 
+{
+lean_object* x_44; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_44 = lean_apply_1(x_8, x_1);
+return x_44;
+}
+}
+}
+}
+lean_object* l_Lean_Expr_find_x3f_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_find_x3f_match__1___rarg), 8, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Expr_find_x3f(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; uint8_t x_4; 
@@ -649,7 +1320,7 @@ x_6 = lean_ctor_get(x_2, 1);
 lean_inc(x_6);
 lean_dec(x_2);
 lean_inc(x_1);
-x_7 = l_Lean_Expr_find_x3f___main(x_1, x_5);
+x_7 = l_Lean_Expr_find_x3f(x_1, x_5);
 if (lean_obj_tag(x_7) == 0)
 {
 x_2 = x_6;
@@ -671,7 +1342,7 @@ x_10 = lean_ctor_get(x_2, 2);
 lean_inc(x_10);
 lean_dec(x_2);
 lean_inc(x_1);
-x_11 = l_Lean_Expr_find_x3f___main(x_1, x_9);
+x_11 = l_Lean_Expr_find_x3f(x_1, x_9);
 if (lean_obj_tag(x_11) == 0)
 {
 x_2 = x_10;
@@ -693,7 +1364,7 @@ x_14 = lean_ctor_get(x_2, 2);
 lean_inc(x_14);
 lean_dec(x_2);
 lean_inc(x_1);
-x_15 = l_Lean_Expr_find_x3f___main(x_1, x_13);
+x_15 = l_Lean_Expr_find_x3f(x_1, x_13);
 if (lean_obj_tag(x_15) == 0)
 {
 x_2 = x_14;
@@ -717,9 +1388,9 @@ x_19 = lean_ctor_get(x_2, 3);
 lean_inc(x_19);
 lean_dec(x_2);
 lean_inc(x_1);
-x_20 = l_Lean_Expr_find_x3f___main(x_1, x_17);
+x_20 = l_Lean_Expr_find_x3f(x_1, x_17);
 lean_inc(x_1);
-x_21 = l_Lean_Expr_find_x3f___main(x_1, x_18);
+x_21 = l_Lean_Expr_find_x3f(x_1, x_18);
 if (lean_obj_tag(x_21) == 0)
 {
 if (lean_obj_tag(x_20) == 0)
@@ -787,512 +1458,50 @@ return x_28;
 }
 }
 }
-lean_object* l_Lean_Expr_find_x3f(lean_object* x_1, lean_object* x_2) {
+uint8_t l_Lean_Expr_occurs___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_3; 
-x_3 = l_Lean_Expr_find_x3f___main(x_1, x_2);
+uint8_t x_3; 
+x_3 = lean_expr_eqv(x_2, x_1);
 return x_3;
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-uint8_t x_5; lean_object* x_6; size_t x_97; size_t x_98; lean_object* x_99; size_t x_100; uint8_t x_101; 
-x_97 = lean_ptr_addr(x_3);
-x_98 = x_2 == 0 ? 0 : x_97 % x_2;
-x_99 = lean_array_uget(x_4, x_98);
-x_100 = lean_ptr_addr(x_99);
-lean_dec(x_99);
-x_101 = x_100 == x_97;
-if (x_101 == 0)
-{
-lean_object* x_102; uint8_t x_103; 
-lean_inc(x_3);
-x_102 = lean_array_uset(x_4, x_98, x_3);
-x_103 = 0;
-x_5 = x_103;
-x_6 = x_102;
-goto block_96;
-}
-else
-{
-uint8_t x_104; 
-x_104 = 1;
-x_5 = x_104;
-x_6 = x_4;
-goto block_96;
-}
-block_96:
-{
-if (x_5 == 0)
-{
-uint8_t x_7; 
-x_7 = lean_expr_eqv(x_3, x_1);
-if (x_7 == 0)
-{
-switch (lean_obj_tag(x_3)) {
-case 5:
-{
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
-x_8 = lean_ctor_get(x_3, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_3, 1);
-lean_inc(x_9);
-lean_dec(x_3);
-x_10 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(x_1, x_2, x_8, x_6);
-x_11 = lean_ctor_get(x_10, 0);
-lean_inc(x_11);
-if (lean_obj_tag(x_11) == 0)
-{
-lean_object* x_12; 
-x_12 = lean_ctor_get(x_10, 1);
-lean_inc(x_12);
-lean_dec(x_10);
-x_3 = x_9;
-x_4 = x_12;
-goto _start;
-}
-else
-{
-uint8_t x_14; 
-lean_dec(x_9);
-x_14 = !lean_is_exclusive(x_10);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = lean_ctor_get(x_10, 0);
-lean_dec(x_15);
-x_16 = !lean_is_exclusive(x_11);
-if (x_16 == 0)
-{
-return x_10;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-x_17 = lean_ctor_get(x_11, 0);
-lean_inc(x_17);
-lean_dec(x_11);
-x_18 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_18, 0, x_17);
-lean_ctor_set(x_10, 0, x_18);
-return x_10;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_10, 1);
-lean_inc(x_19);
-lean_dec(x_10);
-x_20 = lean_ctor_get(x_11, 0);
-lean_inc(x_20);
-if (lean_is_exclusive(x_11)) {
- lean_ctor_release(x_11, 0);
- x_21 = x_11;
-} else {
- lean_dec_ref(x_11);
- x_21 = lean_box(0);
-}
-if (lean_is_scalar(x_21)) {
- x_22 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_22 = x_21;
-}
-lean_ctor_set(x_22, 0, x_20);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_22);
-lean_ctor_set(x_23, 1, x_19);
-return x_23;
-}
-}
-}
-case 6:
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
-x_24 = lean_ctor_get(x_3, 1);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_3, 2);
-lean_inc(x_25);
-lean_dec(x_3);
-x_26 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(x_1, x_2, x_24, x_6);
-x_27 = lean_ctor_get(x_26, 0);
-lean_inc(x_27);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; 
-x_28 = lean_ctor_get(x_26, 1);
-lean_inc(x_28);
-lean_dec(x_26);
-x_3 = x_25;
-x_4 = x_28;
-goto _start;
-}
-else
-{
-uint8_t x_30; 
-lean_dec(x_25);
-x_30 = !lean_is_exclusive(x_26);
-if (x_30 == 0)
-{
-lean_object* x_31; uint8_t x_32; 
-x_31 = lean_ctor_get(x_26, 0);
-lean_dec(x_31);
-x_32 = !lean_is_exclusive(x_27);
-if (x_32 == 0)
-{
-return x_26;
-}
-else
-{
-lean_object* x_33; lean_object* x_34; 
-x_33 = lean_ctor_get(x_27, 0);
-lean_inc(x_33);
-lean_dec(x_27);
-x_34 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_34, 0, x_33);
-lean_ctor_set(x_26, 0, x_34);
-return x_26;
-}
-}
-else
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; 
-x_35 = lean_ctor_get(x_26, 1);
-lean_inc(x_35);
-lean_dec(x_26);
-x_36 = lean_ctor_get(x_27, 0);
-lean_inc(x_36);
-if (lean_is_exclusive(x_27)) {
- lean_ctor_release(x_27, 0);
- x_37 = x_27;
-} else {
- lean_dec_ref(x_27);
- x_37 = lean_box(0);
-}
-if (lean_is_scalar(x_37)) {
- x_38 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_38 = x_37;
-}
-lean_ctor_set(x_38, 0, x_36);
-x_39 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_35);
-return x_39;
-}
-}
-}
-case 7:
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; 
-x_40 = lean_ctor_get(x_3, 1);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_3, 2);
-lean_inc(x_41);
-lean_dec(x_3);
-x_42 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(x_1, x_2, x_40, x_6);
-x_43 = lean_ctor_get(x_42, 0);
-lean_inc(x_43);
-if (lean_obj_tag(x_43) == 0)
-{
-lean_object* x_44; 
-x_44 = lean_ctor_get(x_42, 1);
-lean_inc(x_44);
-lean_dec(x_42);
-x_3 = x_41;
-x_4 = x_44;
-goto _start;
-}
-else
-{
-uint8_t x_46; 
-lean_dec(x_41);
-x_46 = !lean_is_exclusive(x_42);
-if (x_46 == 0)
-{
-lean_object* x_47; uint8_t x_48; 
-x_47 = lean_ctor_get(x_42, 0);
-lean_dec(x_47);
-x_48 = !lean_is_exclusive(x_43);
-if (x_48 == 0)
-{
-return x_42;
-}
-else
-{
-lean_object* x_49; lean_object* x_50; 
-x_49 = lean_ctor_get(x_43, 0);
-lean_inc(x_49);
-lean_dec(x_43);
-x_50 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_50, 0, x_49);
-lean_ctor_set(x_42, 0, x_50);
-return x_42;
-}
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_51 = lean_ctor_get(x_42, 1);
-lean_inc(x_51);
-lean_dec(x_42);
-x_52 = lean_ctor_get(x_43, 0);
-lean_inc(x_52);
-if (lean_is_exclusive(x_43)) {
- lean_ctor_release(x_43, 0);
- x_53 = x_43;
-} else {
- lean_dec_ref(x_43);
- x_53 = lean_box(0);
-}
-if (lean_is_scalar(x_53)) {
- x_54 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_54 = x_53;
-}
-lean_ctor_set(x_54, 0, x_52);
-x_55 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_55, 0, x_54);
-lean_ctor_set(x_55, 1, x_51);
-return x_55;
-}
-}
-}
-case 8:
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-x_56 = lean_ctor_get(x_3, 1);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_3, 2);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_3, 3);
-lean_inc(x_58);
-lean_dec(x_3);
-x_59 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(x_1, x_2, x_56, x_6);
-x_60 = lean_ctor_get(x_59, 0);
-lean_inc(x_60);
-if (lean_obj_tag(x_60) == 0)
-{
-lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_61 = lean_ctor_get(x_59, 1);
-lean_inc(x_61);
-lean_dec(x_59);
-x_62 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(x_1, x_2, x_57, x_61);
-x_63 = lean_ctor_get(x_62, 0);
-lean_inc(x_63);
-if (lean_obj_tag(x_63) == 0)
-{
-lean_object* x_64; 
-x_64 = lean_ctor_get(x_62, 1);
-lean_inc(x_64);
-lean_dec(x_62);
-x_3 = x_58;
-x_4 = x_64;
-goto _start;
-}
-else
-{
-uint8_t x_66; 
-lean_dec(x_58);
-x_66 = !lean_is_exclusive(x_62);
-if (x_66 == 0)
-{
-lean_object* x_67; uint8_t x_68; 
-x_67 = lean_ctor_get(x_62, 0);
-lean_dec(x_67);
-x_68 = !lean_is_exclusive(x_63);
-if (x_68 == 0)
-{
-return x_62;
-}
-else
-{
-lean_object* x_69; lean_object* x_70; 
-x_69 = lean_ctor_get(x_63, 0);
-lean_inc(x_69);
-lean_dec(x_63);
-x_70 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_62, 0, x_70);
-return x_62;
-}
-}
-else
-{
-lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_71 = lean_ctor_get(x_62, 1);
-lean_inc(x_71);
-lean_dec(x_62);
-x_72 = lean_ctor_get(x_63, 0);
-lean_inc(x_72);
-if (lean_is_exclusive(x_63)) {
- lean_ctor_release(x_63, 0);
- x_73 = x_63;
-} else {
- lean_dec_ref(x_63);
- x_73 = lean_box(0);
-}
-if (lean_is_scalar(x_73)) {
- x_74 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_74 = x_73;
-}
-lean_ctor_set(x_74, 0, x_72);
-x_75 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_71);
-return x_75;
-}
-}
-}
-else
-{
-uint8_t x_76; 
-lean_dec(x_58);
-lean_dec(x_57);
-x_76 = !lean_is_exclusive(x_59);
-if (x_76 == 0)
-{
-lean_object* x_77; uint8_t x_78; 
-x_77 = lean_ctor_get(x_59, 0);
-lean_dec(x_77);
-x_78 = !lean_is_exclusive(x_60);
-if (x_78 == 0)
-{
-return x_59;
-}
-else
-{
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_60, 0);
-lean_inc(x_79);
-lean_dec(x_60);
-x_80 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_80, 0, x_79);
-lean_ctor_set(x_59, 0, x_80);
-return x_59;
-}
-}
-else
-{
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; 
-x_81 = lean_ctor_get(x_59, 1);
-lean_inc(x_81);
-lean_dec(x_59);
-x_82 = lean_ctor_get(x_60, 0);
-lean_inc(x_82);
-if (lean_is_exclusive(x_60)) {
- lean_ctor_release(x_60, 0);
- x_83 = x_60;
-} else {
- lean_dec_ref(x_60);
- x_83 = lean_box(0);
-}
-if (lean_is_scalar(x_83)) {
- x_84 = lean_alloc_ctor(1, 1, 0);
-} else {
- x_84 = x_83;
-}
-lean_ctor_set(x_84, 0, x_82);
-x_85 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_85, 0, x_84);
-lean_ctor_set(x_85, 1, x_81);
-return x_85;
-}
-}
-}
-case 10:
-{
-lean_object* x_86; 
-x_86 = lean_ctor_get(x_3, 1);
-lean_inc(x_86);
-lean_dec(x_3);
-x_3 = x_86;
-x_4 = x_6;
-goto _start;
-}
-case 11:
-{
-lean_object* x_88; 
-x_88 = lean_ctor_get(x_3, 2);
-lean_inc(x_88);
-lean_dec(x_3);
-x_3 = x_88;
-x_4 = x_6;
-goto _start;
-}
-default: 
-{
-lean_object* x_90; lean_object* x_91; 
-lean_dec(x_3);
-x_90 = lean_box(0);
-x_91 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_91, 0, x_90);
-lean_ctor_set(x_91, 1, x_6);
-return x_91;
-}
-}
-}
-else
-{
-lean_object* x_92; lean_object* x_93; 
-x_92 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_92, 0, x_3);
-x_93 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_93, 0, x_92);
-lean_ctor_set(x_93, 1, x_6);
-return x_93;
-}
-}
-else
-{
-lean_object* x_94; lean_object* x_95; 
-lean_dec(x_3);
-x_94 = lean_box(0);
-x_95 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_95, 0, x_94);
-lean_ctor_set(x_95, 1, x_6);
-return x_95;
-}
-}
-}
-}
 uint8_t l_Lean_Expr_occurs(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_3 = 8192;
-x_4 = l_Lean_Expr_FindImpl_initCache;
-x_5 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(x_1, x_3, x_2, x_4);
-x_6 = lean_ctor_get(x_5, 0);
-lean_inc(x_6);
-lean_dec(x_5);
-if (lean_obj_tag(x_6) == 0)
+lean_object* x_3; size_t x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
+x_3 = lean_alloc_closure((void*)(l_Lean_Expr_occurs___lambda__1___boxed), 2, 1);
+lean_closure_set(x_3, 0, x_1);
+x_4 = 8192;
+x_5 = l_Lean_Expr_FindImpl_initCache;
+x_6 = l_Lean_Expr_FindImpl_findM_x3f_visit(x_3, x_4, x_2, x_5);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_7) == 0)
 {
-uint8_t x_7; 
-x_7 = 0;
-return x_7;
+uint8_t x_8; 
+x_8 = 0;
+return x_8;
 }
 else
 {
-uint8_t x_8; 
-lean_dec(x_6);
-x_8 = 1;
-return x_8;
+uint8_t x_9; 
+lean_dec(x_7);
+x_9 = 1;
+return x_9;
 }
 }
 }
-lean_object* l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_Expr_occurs___lambda__1___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-size_t x_5; lean_object* x_6; 
-x_5 = lean_unbox_usize(x_2);
+uint8_t x_3; lean_object* x_4; 
+x_3 = l_Lean_Expr_occurs___lambda__1(x_1, x_2);
 lean_dec(x_2);
-x_6 = l_Lean_Expr_FindImpl_findM_x3f___main___at_Lean_Expr_occurs___spec__1(x_1, x_5, x_3, x_4);
 lean_dec(x_1);
-return x_6;
+x_4 = lean_box(x_3);
+return x_4;
 }
 }
 lean_object* l_Lean_Expr_occurs___boxed(lean_object* x_1, lean_object* x_2) {
@@ -1300,7 +1509,6 @@ _start:
 {
 uint8_t x_3; lean_object* x_4; 
 x_3 = l_Lean_Expr_occurs(x_1, x_2);
-lean_dec(x_1);
 x_4 = lean_box(x_3);
 return x_4;
 }
diff --git a/stage0/stdlib/Lean/Util/FindMVar.c b/stage0/stdlib/Lean/Util/FindMVar.c
index b5dd2bd95c..f977599969 100644
--- a/stage0/stdlib/Lean/Util/FindMVar.c
+++ b/stage0/stdlib/Lean/Util/FindMVar.c
@@ -13,11 +13,190 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Lean_FindMVar_main_match__1(lean_object*);
+lean_object* l_Lean_FindMVar_main___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_FindMVar_visit(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_findMVar_x3f(lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_visit___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_hasMVar(lean_object*);
+lean_object* l_Lean_FindMVar_main_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_FindMVar_main(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_FindMVar_main___main(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_FindMVar_main_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 2:
+{
+lean_object* x_10; uint64_t x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get_uint64(x_1, sizeof(void*)*1);
+lean_dec(x_1);
+x_12 = lean_box_uint64(x_11);
+x_13 = lean_apply_2(x_8, x_10, x_12);
+return x_13;
+}
+case 5:
+{
+lean_object* x_14; lean_object* x_15; uint64_t x_16; lean_object* x_17; lean_object* x_18; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_1, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_17 = lean_box_uint64(x_16);
+x_18 = lean_apply_3(x_6, x_14, x_15, x_17);
+return x_18;
+}
+case 6:
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; uint64_t x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_19 = lean_ctor_get(x_1, 0);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_1, 1);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_1, 2);
+lean_inc(x_21);
+x_22 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_23 = lean_box_uint64(x_22);
+x_24 = lean_apply_4(x_4, x_19, x_20, x_21, x_23);
+return x_24;
+}
+case 7:
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; uint64_t x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_25 = lean_ctor_get(x_1, 0);
+lean_inc(x_25);
+x_26 = lean_ctor_get(x_1, 1);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_1, 2);
+lean_inc(x_27);
+x_28 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_29 = lean_box_uint64(x_28);
+x_30 = lean_apply_4(x_3, x_25, x_26, x_27, x_29);
+return x_30;
+}
+case 8:
+{
+lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint64_t x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_31 = lean_ctor_get(x_1, 0);
+lean_inc(x_31);
+x_32 = lean_ctor_get(x_1, 1);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_1, 2);
+lean_inc(x_33);
+x_34 = lean_ctor_get(x_1, 3);
+lean_inc(x_34);
+x_35 = lean_ctor_get_uint64(x_1, sizeof(void*)*4);
+lean_dec(x_1);
+x_36 = lean_box_uint64(x_35);
+x_37 = lean_apply_5(x_5, x_31, x_32, x_33, x_34, x_36);
+return x_37;
+}
+case 10:
+{
+lean_object* x_38; lean_object* x_39; uint64_t x_40; lean_object* x_41; lean_object* x_42; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_38 = lean_ctor_get(x_1, 0);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_1, 1);
+lean_inc(x_39);
+x_40 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_41 = lean_box_uint64(x_40);
+x_42 = lean_apply_3(x_7, x_38, x_39, x_41);
+return x_42;
+}
+case 11:
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; uint64_t x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_43 = lean_ctor_get(x_1, 0);
+lean_inc(x_43);
+x_44 = lean_ctor_get(x_1, 1);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_1, 2);
+lean_inc(x_45);
+x_46 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_47 = lean_box_uint64(x_46);
+x_48 = lean_apply_4(x_2, x_43, x_44, x_45, x_47);
+return x_48;
+}
+default: 
+{
+lean_object* x_49; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_49 = lean_apply_1(x_9, x_1);
+return x_49;
+}
+}
+}
+}
+lean_object* l_Lean_FindMVar_main_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_FindMVar_main_match__1___rarg), 9, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_FindMVar_visit(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -34,7 +213,7 @@ return x_3;
 else
 {
 lean_object* x_5; 
-x_5 = lean_apply_2(x_1, x_2, x_3);
+x_5 = l_Lean_FindMVar_main(x_1, x_2, x_3);
 return x_5;
 }
 }
@@ -42,11 +221,12 @@ else
 {
 lean_dec(x_2);
 lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
 }
-lean_object* l_Lean_FindMVar_main___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_FindMVar_main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 switch (lean_obj_tag(x_2)) {
@@ -79,383 +259,114 @@ else
 {
 lean_dec(x_2);
 lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
 case 5:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_8; lean_object* x_9; uint8_t x_10; 
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_8 = lean_ctor_get(x_2, 0);
 lean_inc(x_8);
 x_9 = lean_ctor_get(x_2, 1);
 lean_inc(x_9);
 lean_dec(x_2);
-x_10 = l_Lean_Expr_hasMVar(x_8);
-if (x_10 == 0)
-{
-uint8_t x_11; 
-lean_dec(x_8);
-x_11 = l_Lean_Expr_hasMVar(x_9);
-if (x_11 == 0)
-{
-lean_dec(x_9);
-lean_dec(x_1);
-return x_3;
-}
-else
-{
-x_2 = x_9;
-goto _start;
-}
-}
-else
-{
-lean_object* x_13; 
 lean_inc(x_1);
-x_13 = l_Lean_FindMVar_main___main(x_1, x_8, x_3);
-if (lean_obj_tag(x_13) == 0)
-{
-uint8_t x_14; 
-x_14 = l_Lean_Expr_hasMVar(x_9);
-if (x_14 == 0)
-{
-lean_dec(x_9);
-lean_dec(x_1);
-return x_13;
-}
-else
-{
-x_2 = x_9;
-x_3 = x_13;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_9);
-lean_dec(x_1);
-return x_13;
-}
-}
-}
-else
-{
-lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
-}
+x_10 = l_Lean_FindMVar_visit(x_1, x_8, x_3);
+x_11 = l_Lean_FindMVar_visit(x_1, x_9, x_10);
+lean_dec(x_10);
+return x_11;
 }
 case 6:
 {
-if (lean_obj_tag(x_3) == 0)
+lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
+x_12 = lean_ctor_get(x_2, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_2, 2);
+lean_inc(x_13);
+lean_dec(x_2);
+lean_inc(x_1);
+x_14 = l_Lean_FindMVar_visit(x_1, x_12, x_3);
+x_15 = l_Lean_FindMVar_visit(x_1, x_13, x_14);
+lean_dec(x_14);
+return x_15;
+}
+case 7:
 {
-lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
 x_16 = lean_ctor_get(x_2, 1);
 lean_inc(x_16);
 x_17 = lean_ctor_get(x_2, 2);
 lean_inc(x_17);
 lean_dec(x_2);
-x_18 = l_Lean_Expr_hasMVar(x_16);
-if (x_18 == 0)
-{
-uint8_t x_19; 
-lean_dec(x_16);
-x_19 = l_Lean_Expr_hasMVar(x_17);
-if (x_19 == 0)
-{
-lean_dec(x_17);
-lean_dec(x_1);
-return x_3;
-}
-else
-{
-x_2 = x_17;
-goto _start;
-}
-}
-else
-{
-lean_object* x_21; 
 lean_inc(x_1);
-x_21 = l_Lean_FindMVar_main___main(x_1, x_16, x_3);
-if (lean_obj_tag(x_21) == 0)
-{
-uint8_t x_22; 
-x_22 = l_Lean_Expr_hasMVar(x_17);
-if (x_22 == 0)
-{
-lean_dec(x_17);
-lean_dec(x_1);
-return x_21;
-}
-else
-{
-x_2 = x_17;
-x_3 = x_21;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_17);
-lean_dec(x_1);
-return x_21;
-}
-}
-}
-else
-{
-lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
-}
-}
-case 7:
-{
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_24 = lean_ctor_get(x_2, 1);
-lean_inc(x_24);
-x_25 = lean_ctor_get(x_2, 2);
-lean_inc(x_25);
-lean_dec(x_2);
-x_26 = l_Lean_Expr_hasMVar(x_24);
-if (x_26 == 0)
-{
-uint8_t x_27; 
-lean_dec(x_24);
-x_27 = l_Lean_Expr_hasMVar(x_25);
-if (x_27 == 0)
-{
-lean_dec(x_25);
-lean_dec(x_1);
-return x_3;
-}
-else
-{
-x_2 = x_25;
-goto _start;
-}
-}
-else
-{
-lean_object* x_29; 
-lean_inc(x_1);
-x_29 = l_Lean_FindMVar_main___main(x_1, x_24, x_3);
-if (lean_obj_tag(x_29) == 0)
-{
-uint8_t x_30; 
-x_30 = l_Lean_Expr_hasMVar(x_25);
-if (x_30 == 0)
-{
-lean_dec(x_25);
-lean_dec(x_1);
-return x_29;
-}
-else
-{
-x_2 = x_25;
-x_3 = x_29;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_25);
-lean_dec(x_1);
-return x_29;
-}
-}
-}
-else
-{
-lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
-}
+x_18 = l_Lean_FindMVar_visit(x_1, x_16, x_3);
+x_19 = l_Lean_FindMVar_visit(x_1, x_17, x_18);
+lean_dec(x_18);
+return x_19;
 }
 case 8:
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_2, 1);
-lean_inc(x_32);
-x_33 = lean_ctor_get(x_2, 2);
-lean_inc(x_33);
-x_34 = lean_ctor_get(x_2, 3);
-lean_inc(x_34);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+x_20 = lean_ctor_get(x_2, 1);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_2, 2);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_2, 3);
+lean_inc(x_22);
 lean_dec(x_2);
-if (lean_obj_tag(x_3) == 0)
-{
-uint8_t x_43; 
-x_43 = l_Lean_Expr_hasMVar(x_32);
-if (x_43 == 0)
-{
-lean_dec(x_32);
-x_35 = x_3;
-goto block_42;
-}
-else
-{
-lean_object* x_44; 
 lean_inc(x_1);
-x_44 = l_Lean_FindMVar_main___main(x_1, x_32, x_3);
-if (lean_obj_tag(x_44) == 0)
-{
-x_35 = x_44;
-goto block_42;
-}
-else
-{
-lean_dec(x_34);
-lean_dec(x_33);
-lean_dec(x_1);
-return x_44;
-}
-}
-}
-else
-{
-lean_dec(x_34);
-lean_dec(x_33);
-lean_dec(x_32);
-lean_dec(x_1);
-return x_3;
-}
-block_42:
-{
-uint8_t x_36; 
-x_36 = l_Lean_Expr_hasMVar(x_33);
-if (x_36 == 0)
-{
-lean_dec(x_33);
-if (lean_obj_tag(x_35) == 0)
-{
-uint8_t x_37; 
-x_37 = l_Lean_Expr_hasMVar(x_34);
-if (x_37 == 0)
-{
-lean_dec(x_34);
-lean_dec(x_1);
-return x_35;
-}
-else
-{
-x_2 = x_34;
-x_3 = x_35;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_34);
-lean_dec(x_1);
-return x_35;
-}
-}
-else
-{
-lean_object* x_39; 
+x_23 = l_Lean_FindMVar_visit(x_1, x_20, x_3);
 lean_inc(x_1);
-x_39 = l_Lean_FindMVar_main___main(x_1, x_33, x_35);
-if (lean_obj_tag(x_39) == 0)
-{
-uint8_t x_40; 
-x_40 = l_Lean_Expr_hasMVar(x_34);
-if (x_40 == 0)
-{
-lean_dec(x_34);
-lean_dec(x_1);
-return x_39;
-}
-else
-{
-x_2 = x_34;
-x_3 = x_39;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_34);
-lean_dec(x_1);
-return x_39;
-}
-}
-}
+x_24 = l_Lean_FindMVar_visit(x_1, x_21, x_23);
+lean_dec(x_23);
+x_25 = l_Lean_FindMVar_visit(x_1, x_22, x_24);
+lean_dec(x_24);
+return x_25;
 }
 case 10:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_45; uint8_t x_46; 
-x_45 = lean_ctor_get(x_2, 1);
-lean_inc(x_45);
+lean_object* x_26; lean_object* x_27; 
+x_26 = lean_ctor_get(x_2, 1);
+lean_inc(x_26);
 lean_dec(x_2);
-x_46 = l_Lean_Expr_hasMVar(x_45);
-if (x_46 == 0)
-{
-lean_dec(x_45);
-lean_dec(x_1);
-return x_3;
-}
-else
-{
-x_2 = x_45;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
-}
+x_27 = l_Lean_FindMVar_visit(x_1, x_26, x_3);
+return x_27;
 }
 case 11:
 {
-if (lean_obj_tag(x_3) == 0)
-{
-lean_object* x_48; uint8_t x_49; 
-x_48 = lean_ctor_get(x_2, 2);
-lean_inc(x_48);
+lean_object* x_28; lean_object* x_29; 
+x_28 = lean_ctor_get(x_2, 2);
+lean_inc(x_28);
 lean_dec(x_2);
-x_49 = l_Lean_Expr_hasMVar(x_48);
-if (x_49 == 0)
-{
-lean_dec(x_48);
-lean_dec(x_1);
-return x_3;
-}
-else
-{
-x_2 = x_48;
-goto _start;
-}
-}
-else
-{
-lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
-}
+x_29 = l_Lean_FindMVar_visit(x_1, x_28, x_3);
+return x_29;
 }
 default: 
 {
 lean_dec(x_2);
 lean_dec(x_1);
+lean_inc(x_3);
 return x_3;
 }
 }
 }
 }
-lean_object* l_Lean_FindMVar_main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Lean_FindMVar_visit___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Lean_FindMVar_main___main(x_1, x_2, x_3);
+x_4 = l_Lean_FindMVar_visit(x_1, x_2, x_3);
+lean_dec(x_3);
+return x_4;
+}
+}
+lean_object* l_Lean_FindMVar_main___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_FindMVar_main(x_1, x_2, x_3);
+lean_dec(x_3);
 return x_4;
 }
 }
@@ -464,7 +375,7 @@ _start:
 {
 lean_object* x_3; lean_object* x_4; 
 x_3 = lean_box(0);
-x_4 = l_Lean_FindMVar_main___main(x_2, x_1, x_3);
+x_4 = l_Lean_FindMVar_main(x_2, x_1, x_3);
 return x_4;
 }
 }
diff --git a/stage0/stdlib/Lean/Util/Path.c b/stage0/stdlib/Lean/Util/Path.c
index fe41199c26..e9377f8d0e 100644
--- a/stage0/stdlib/Lean/Util/Path.c
+++ b/stage0/stdlib/Lean/Util/Path.c
@@ -13,15 +13,16 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Lean_moduleNameOfFileName___lambda__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath___closed__6;
 lean_object* l_IO_isDir___at_Lean_findOLean___spec__1___boxed(lean_object*, lean_object*);
 lean_object* lean_io_is_dir(lean_object*, lean_object*);
 lean_object* l_String_revPosOf(lean_object*, uint32_t);
-lean_object* l___private_Lean_Util_Path_1__pathSep;
+lean_object* l_Lean_modPathToFilePath_match__1(lean_object*);
 lean_object* l_Lean_searchPathRef;
-lean_object* l___private_Init_Util_1__mkPanicMessage(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_get(lean_object*, lean_object*);
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
+lean_object* l_Lean_addSearchPathFromEnv_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath(lean_object*);
 lean_object* l_Lean_mkSearchPathRef(lean_object*);
 lean_object* l_Lean_parseSearchPath___boxed(lean_object*, lean_object*, lean_object*);
@@ -30,41 +31,46 @@ lean_object* lean_string_utf8_extract(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l_IO_getEnv___at_Lean_addSearchPathFromEnv___spec__1___boxed(lean_object*, lean_object*);
 lean_object* l_String_splitOn(lean_object*, lean_object*);
-lean_object* l_Lean_modPathToFilePath___main___closed__3;
 lean_object* lean_io_getenv(lean_object*, lean_object*);
-lean_object* l_Lean_modPathToFilePath___main___closed__2;
+lean_object* l_Lean_moduleNameOfFileName___lambda__2___closed__1;
+lean_object* l_Lean_moduleNameOfFileName_match__1(lean_object*);
 lean_object* l_Lean_findOLean(lean_object*, lean_object*);
-lean_object* l_Lean_modPathToFilePath___main___closed__1;
-lean_object* l_Lean_modPathToFilePath___main(lean_object*);
 extern lean_object* l_ULift_HasRepr___rarg___closed__2;
 lean_object* l_Lean_getBuiltinSearchPath___closed__8;
 lean_object* l_IO_mkRef___at_Lean_mkSearchPathRef___spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_findOLean_match__1(lean_object*);
 lean_object* l_Lean_isStage0___boxed(lean_object*);
+lean_object* l_Lean_moduleNameOfFileName___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_io_current_dir(lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath___closed__1;
+lean_object* l_Lean_moduleNameOfFileName___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_moduleNameOfFileName___lambda__1___closed__1;
 lean_object* l_Lean_addSearchPathFromEnv___closed__1;
+lean_object* l_Lean_modPathToFilePath___closed__4;
+lean_object* l_Lean_moduleNameOfFileName___lambda__1___closed__2;
 lean_object* lean_io_realpath(lean_object*, lean_object*);
-lean_object* l_Lean_moduleNameOfFileName___closed__2;
+lean_object* l_Lean_modPathToFilePath___closed__1;
 lean_object* l_System_FilePath_dirName(lean_object*);
-lean_object* l_Lean_moduleNameOfFileName___closed__1;
 extern lean_object* l_Char_HasRepr___closed__1;
 lean_object* l_System_FilePath_normalizePath(lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath___closed__5;
 lean_object* lean_st_mk_ref(lean_object*, lean_object*);
+lean_object* l_Lean_modPathToFilePath___closed__2;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean___closed__2;
 lean_object* l_Lean_modPathToFilePath___boxed(lean_object*);
-lean_object* l_Lean_modPathToFilePath___main___boxed(lean_object*);
-lean_object* l_Lean_moduleNameOfFileName___closed__4;
+lean_object* l_Lean_moduleNameOfFileName_match__1___rarg(lean_object*, lean_object*, lean_object*);
 extern uint32_t l_System_FilePath_pathSeparator;
 uint32_t lean_string_utf8_get(lean_object*, lean_object*);
 lean_object* lean_module_name_of_file(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_appDir___at_Lean_getBuiltinSearchPath___spec__1(lean_object*);
 lean_object* l_String_split___at_System_FilePath_splitSearchPath___spec__2(lean_object*);
+lean_object* l_Lean_modPathToFilePath___closed__3;
 lean_object* l_Lean_realPathNormalized(lean_object*, lean_object*);
 lean_object* l_IO_getEnv___at_Lean_addSearchPathFromEnv___spec__1(lean_object*, lean_object*);
+lean_object* l_Lean_initSearchPath_match__1(lean_object*);
 lean_object* lean_init_search_path(lean_object*, lean_object*);
-lean_object* l_Lean_moduleNameOfFileName___closed__3;
+lean_object* l_Lean_addSearchPathFromEnv_match__1(lean_object*);
 lean_object* l_List_findM_x3f___main___at_Lean_findOLean___spec__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_isDir___at_Lean_findOLean___spec__1(lean_object*, lean_object*);
 lean_object* l_Lean_findOLean___closed__1;
@@ -73,17 +79,22 @@ lean_object* l_List_foldl___main___at_Lean_moduleNameOfFileName___spec__1(lean_o
 lean_object* l_Lean_findOLean___boxed(lean_object*, lean_object*);
 uint8_t l_String_isPrefixOf(lean_object*, lean_object*);
 lean_object* l_IO_currentDir___at_Lean_moduleNameOfFileName___spec__2(lean_object*);
+lean_object* l_Lean_modPathToFilePath_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_isStage0(lean_object*);
 lean_object* lean_panic_fn(lean_object*, lean_object*);
 lean_object* l_Lean_addSearchPathFromEnv(lean_object*, lean_object*);
 uint8_t l_Lean_getBuiltinSearchPath___closed__2;
+lean_object* l_Lean_moduleNameOfFileName_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath___closed__4;
 extern lean_object* l_System_mkFilePath___closed__1;
+lean_object* l_Lean_findOLean_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath___closed__7;
+lean_object* l_Lean_initSearchPath_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_parseSearchPath(lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_appPath___at_Lean_getBuiltinSearchPath___spec__2(lean_object*);
-lean_object* l_Lean_Name_getRoot___main(lean_object*);
+lean_object* l_Lean_moduleNameOfFileName___lambda__2___closed__2;
+lean_object* l_Lean_moduleNameOfFileName_match__2(lean_object*);
 lean_object* lean_string_length(lean_object*);
 lean_object* l_Lean_modPathToFilePath(lean_object*);
 lean_object* l_List_findM_x3f___main___at_Lean_findOLean___spec__2(lean_object*, lean_object*, lean_object*);
@@ -91,10 +102,13 @@ lean_object* lean_io_app_dir(lean_object*);
 extern lean_object* l_System_FilePath_dirName___closed__1;
 lean_object* l_String_drop(lean_object*, lean_object*);
 lean_object* l_Lean_Name_toStringWithSep___main(lean_object*, lean_object*);
+lean_object* l_Lean_Name_getRoot(lean_object*);
 lean_object* l_Lean_getBuiltinSearchPath___closed__3;
 extern lean_object* l_String_Inhabited;
+lean_object* l___private_Lean_Util_Path_0__Lean_pathSep;
+lean_object* l___private_Init_Util_2__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_IO_realPath___at_Lean_realPathNormalized___spec__1(lean_object*, lean_object*);
-static lean_object* _init_l___private_Lean_Util_Path_1__pathSep() {
+static lean_object* _init_l___private_Lean_Util_Path_0__Lean_pathSep() {
 _start:
 {
 lean_object* x_1; 
@@ -316,7 +330,7 @@ static lean_object* _init_l_Lean_getBuiltinSearchPath___closed__5() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
-x_1 = l___private_Lean_Util_Path_1__pathSep;
+x_1 = l___private_Lean_Util_Path_0__Lean_pathSep;
 x_2 = l_Lean_getBuiltinSearchPath___closed__1;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
@@ -327,7 +341,7 @@ _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = l_Lean_getBuiltinSearchPath___closed__5;
-x_2 = l___private_Lean_Util_Path_1__pathSep;
+x_2 = l___private_Lean_Util_Path_0__Lean_pathSep;
 x_3 = lean_string_append(x_1, x_2);
 return x_3;
 }
@@ -363,7 +377,7 @@ if (x_3 == 0)
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
 x_4 = lean_ctor_get(x_2, 0);
-x_5 = l___private_Lean_Util_Path_1__pathSep;
+x_5 = l___private_Lean_Util_Path_0__Lean_pathSep;
 x_6 = lean_string_append(x_4, x_5);
 x_7 = l_Lean_getBuiltinSearchPath___closed__1;
 x_8 = lean_string_append(x_6, x_7);
@@ -412,7 +426,7 @@ x_30 = lean_ctor_get(x_2, 1);
 lean_inc(x_30);
 lean_inc(x_29);
 lean_dec(x_2);
-x_31 = l___private_Lean_Util_Path_1__pathSep;
+x_31 = l___private_Lean_Util_Path_0__Lean_pathSep;
 x_32 = lean_string_append(x_29, x_31);
 x_33 = l_Lean_getBuiltinSearchPath___closed__1;
 x_34 = lean_string_append(x_32, x_33);
@@ -482,6 +496,37 @@ return x_60;
 }
 }
 }
+lean_object* l_Lean_addSearchPathFromEnv_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_addSearchPathFromEnv_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_addSearchPathFromEnv_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_IO_getEnv___at_Lean_addSearchPathFromEnv___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -581,6 +626,37 @@ lean_dec(x_1);
 return x_3;
 }
 }
+lean_object* l_Lean_initSearchPath_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_initSearchPath_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_initSearchPath_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* lean_init_search_path(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -709,7 +785,61 @@ return x_33;
 }
 }
 }
-static lean_object* _init_l_Lean_modPathToFilePath___main___closed__1() {
+lean_object* l_Lean_modPathToFilePath_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 0:
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_3, x_5);
+return x_6;
+}
+case 1:
+{
+lean_object* x_7; lean_object* x_8; size_t x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_10 = lean_box_usize(x_9);
+x_11 = lean_apply_3(x_2, x_7, x_8, x_10);
+return x_11;
+}
+default: 
+{
+lean_object* x_12; lean_object* x_13; size_t x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get_usize(x_1, 2);
+lean_dec(x_1);
+x_15 = lean_box_usize(x_14);
+x_16 = lean_apply_3(x_4, x_12, x_13, x_15);
+return x_16;
+}
+}
+}
+}
+lean_object* l_Lean_modPathToFilePath_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_modPathToFilePath_match__1___rarg), 4, 0);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_modPathToFilePath___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -717,7 +847,15 @@ x_1 = lean_mk_string("Lean.Util.Path");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_modPathToFilePath___main___closed__2() {
+static lean_object* _init_l_Lean_modPathToFilePath___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("Lean.modPathToFilePath");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_modPathToFilePath___closed__3() {
 _start:
 {
 lean_object* x_1; 
@@ -725,19 +863,20 @@ x_1 = lean_mk_string("ill-formed import");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_modPathToFilePath___main___closed__3() {
+static lean_object* _init_l_Lean_modPathToFilePath___closed__4() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
-x_1 = l_Lean_modPathToFilePath___main___closed__1;
-x_2 = lean_unsigned_to_nat(58u);
-x_3 = lean_unsigned_to_nat(33u);
-x_4 = l_Lean_modPathToFilePath___main___closed__2;
-x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
-return x_5;
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+x_1 = l_Lean_modPathToFilePath___closed__1;
+x_2 = l_Lean_modPathToFilePath___closed__2;
+x_3 = lean_unsigned_to_nat(59u);
+x_4 = lean_unsigned_to_nat(33u);
+x_5 = l_Lean_modPathToFilePath___closed__3;
+x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
+return x_6;
 }
 }
-lean_object* l_Lean_modPathToFilePath___main(lean_object* x_1) {
+lean_object* l_Lean_modPathToFilePath(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -752,8 +891,8 @@ case 1:
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
 x_3 = lean_ctor_get(x_1, 0);
 x_4 = lean_ctor_get(x_1, 1);
-x_5 = l_Lean_modPathToFilePath___main(x_3);
-x_6 = l___private_Lean_Util_Path_1__pathSep;
+x_5 = l_Lean_modPathToFilePath(x_3);
+x_6 = l___private_Lean_Util_Path_0__Lean_pathSep;
 x_7 = lean_string_append(x_5, x_6);
 x_8 = lean_string_append(x_7, x_4);
 return x_8;
@@ -762,30 +901,13 @@ default:
 {
 lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 x_9 = l_String_Inhabited;
-x_10 = l_Lean_modPathToFilePath___main___closed__3;
+x_10 = l_Lean_modPathToFilePath___closed__4;
 x_11 = lean_panic_fn(x_9, x_10);
 return x_11;
 }
 }
 }
 }
-lean_object* l_Lean_modPathToFilePath___main___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_modPathToFilePath___main(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_Lean_modPathToFilePath(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Lean_modPathToFilePath___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_modPathToFilePath___boxed(lean_object* x_1) {
 _start:
 {
@@ -795,6 +917,36 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_Lean_findOLean_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+}
+}
+lean_object* l_Lean_findOLean_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_findOLean_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_IO_isDir___at_Lean_findOLean___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -823,7 +975,7 @@ lean_inc(x_6);
 x_7 = lean_ctor_get(x_2, 1);
 lean_inc(x_7);
 lean_dec(x_2);
-x_8 = l___private_Lean_Util_Path_1__pathSep;
+x_8 = l___private_Lean_Util_Path_0__Lean_pathSep;
 lean_inc(x_6);
 x_9 = lean_string_append(x_6, x_8);
 x_10 = lean_string_append(x_9, x_1);
@@ -931,7 +1083,7 @@ lean_inc(x_5);
 x_6 = lean_ctor_get(x_4, 1);
 lean_inc(x_6);
 lean_dec(x_4);
-x_7 = l_Lean_Name_getRoot___main(x_1);
+x_7 = l_Lean_Name_getRoot(x_1);
 x_8 = l_System_FilePath_dirName___closed__1;
 x_9 = l_Lean_Name_toStringWithSep___main(x_8, x_7);
 x_10 = l_List_findM_x3f___main___at_Lean_findOLean___spec__2(x_9, x_5, x_6);
@@ -992,7 +1144,7 @@ lean_dec(x_27);
 x_28 = lean_ctor_get(x_11, 0);
 lean_inc(x_28);
 lean_dec(x_11);
-x_29 = l_Lean_modPathToFilePath___main(x_1);
+x_29 = l_Lean_modPathToFilePath(x_1);
 x_30 = lean_string_append(x_28, x_29);
 lean_dec(x_29);
 x_31 = l_Lean_findOLean___closed__2;
@@ -1009,7 +1161,7 @@ lean_dec(x_10);
 x_34 = lean_ctor_get(x_11, 0);
 lean_inc(x_34);
 lean_dec(x_11);
-x_35 = l_Lean_modPathToFilePath___main(x_1);
+x_35 = l_Lean_modPathToFilePath(x_1);
 x_36 = lean_string_append(x_34, x_35);
 lean_dec(x_35);
 x_37 = l_Lean_findOLean___closed__2;
@@ -1073,6 +1225,67 @@ lean_dec(x_1);
 return x_3;
 }
 }
+lean_object* l_Lean_moduleNameOfFileName_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_moduleNameOfFileName_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_moduleNameOfFileName_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_moduleNameOfFileName_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_3);
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+}
+}
+lean_object* l_Lean_moduleNameOfFileName_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_moduleNameOfFileName_match__2___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_List_foldl___main___at_Lean_moduleNameOfFileName___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1103,23 +1316,7 @@ x_2 = lean_io_current_dir(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_moduleNameOfFileName___closed__1() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("input file '");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_moduleNameOfFileName___closed__2() {
-_start:
-{
-lean_object* x_1; 
-x_1 = lean_mk_string("' must be contained in root directory (");
-return x_1;
-}
-}
-static lean_object* _init_l_Lean_moduleNameOfFileName___closed__3() {
+static lean_object* _init_l_Lean_moduleNameOfFileName___lambda__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -1127,7 +1324,7 @@ x_1 = lean_mk_string("failed to convert file name '");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_moduleNameOfFileName___closed__4() {
+static lean_object* _init_l_Lean_moduleNameOfFileName___lambda__1___closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -1135,6 +1332,241 @@ x_1 = lean_mk_string("' to module name, extension is missing");
 return x_1;
 }
 }
+lean_object* l_Lean_moduleNameOfFileName___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; uint32_t x_8; uint32_t x_9; uint8_t x_10; uint32_t x_11; uint8_t x_12; 
+x_5 = lean_string_length(x_1);
+lean_inc(x_2);
+x_6 = l_String_drop(x_2, x_5);
+x_7 = lean_unsigned_to_nat(0u);
+x_8 = lean_string_utf8_get(x_6, x_7);
+x_9 = l_System_FilePath_pathSeparator;
+x_10 = x_8 == x_9;
+x_11 = 46;
+if (x_10 == 0)
+{
+uint8_t x_44; 
+x_44 = 0;
+x_12 = x_44;
+goto block_43;
+}
+else
+{
+uint8_t x_45; 
+x_45 = 1;
+x_12 = x_45;
+goto block_43;
+}
+block_43:
+{
+if (x_12 == 0)
+{
+lean_object* x_13; 
+x_13 = l_String_revPosOf(x_6, x_11);
+if (lean_obj_tag(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_dec(x_6);
+x_14 = l_Lean_moduleNameOfFileName___lambda__1___closed__1;
+x_15 = lean_string_append(x_14, x_2);
+lean_dec(x_2);
+x_16 = l_Lean_moduleNameOfFileName___lambda__1___closed__2;
+x_17 = lean_string_append(x_15, x_16);
+x_18 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_18, 0, x_17);
+x_19 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_19, 0, x_18);
+lean_ctor_set(x_19, 1, x_4);
+return x_19;
+}
+else
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_2);
+x_20 = lean_ctor_get(x_13, 0);
+lean_inc(x_20);
+lean_dec(x_13);
+x_21 = lean_string_utf8_extract(x_6, x_7, x_20);
+lean_dec(x_20);
+lean_dec(x_6);
+x_22 = l___private_Lean_Util_Path_0__Lean_pathSep;
+x_23 = l_String_splitOn(x_21, x_22);
+x_24 = lean_box(0);
+x_25 = l_List_foldl___main___at_Lean_moduleNameOfFileName___spec__1(x_24, x_23);
+x_26 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_26, 0, x_25);
+lean_ctor_set(x_26, 1, x_4);
+return x_26;
+}
+}
+else
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+x_27 = lean_unsigned_to_nat(1u);
+x_28 = l_String_drop(x_6, x_27);
+x_29 = l_String_revPosOf(x_28, x_11);
+if (lean_obj_tag(x_29) == 0)
+{
+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_dec(x_28);
+x_30 = l_Lean_moduleNameOfFileName___lambda__1___closed__1;
+x_31 = lean_string_append(x_30, x_2);
+lean_dec(x_2);
+x_32 = l_Lean_moduleNameOfFileName___lambda__1___closed__2;
+x_33 = lean_string_append(x_31, x_32);
+x_34 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_34, 0, x_33);
+x_35 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_35, 0, x_34);
+lean_ctor_set(x_35, 1, x_4);
+return x_35;
+}
+else
+{
+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_dec(x_2);
+x_36 = lean_ctor_get(x_29, 0);
+lean_inc(x_36);
+lean_dec(x_29);
+x_37 = lean_string_utf8_extract(x_28, x_7, x_36);
+lean_dec(x_36);
+lean_dec(x_28);
+x_38 = l___private_Lean_Util_Path_0__Lean_pathSep;
+x_39 = l_String_splitOn(x_37, x_38);
+x_40 = lean_box(0);
+x_41 = l_List_foldl___main___at_Lean_moduleNameOfFileName___spec__1(x_40, x_39);
+x_42 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_42, 0, x_41);
+lean_ctor_set(x_42, 1, x_4);
+return x_42;
+}
+}
+}
+}
+}
+static lean_object* _init_l_Lean_moduleNameOfFileName___lambda__2___closed__1() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("input file '");
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_moduleNameOfFileName___lambda__2___closed__2() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_mk_string("' must be contained in root directory (");
+return x_1;
+}
+}
+lean_object* l_Lean_moduleNameOfFileName___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_realPathNormalized(x_2, x_3);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_5; 
+x_5 = !lean_is_exclusive(x_4);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; uint8_t x_8; 
+x_6 = lean_ctor_get(x_4, 0);
+x_7 = lean_ctor_get(x_4, 1);
+x_8 = l_String_isPrefixOf(x_6, x_1);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_9 = l_Lean_moduleNameOfFileName___lambda__2___closed__1;
+x_10 = lean_string_append(x_9, x_1);
+lean_dec(x_1);
+x_11 = l_Lean_moduleNameOfFileName___lambda__2___closed__2;
+x_12 = lean_string_append(x_10, x_11);
+x_13 = lean_string_append(x_12, x_6);
+lean_dec(x_6);
+x_14 = l_ULift_HasRepr___rarg___closed__2;
+x_15 = lean_string_append(x_13, x_14);
+x_16 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_16, 0, x_15);
+lean_ctor_set_tag(x_4, 1);
+lean_ctor_set(x_4, 0, x_16);
+return x_4;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; 
+lean_free_object(x_4);
+x_17 = lean_box(0);
+x_18 = l_Lean_moduleNameOfFileName___lambda__1(x_6, x_1, x_17, x_7);
+lean_dec(x_6);
+return x_18;
+}
+}
+else
+{
+lean_object* x_19; lean_object* x_20; uint8_t x_21; 
+x_19 = lean_ctor_get(x_4, 0);
+x_20 = lean_ctor_get(x_4, 1);
+lean_inc(x_20);
+lean_inc(x_19);
+lean_dec(x_4);
+x_21 = l_String_isPrefixOf(x_19, x_1);
+if (x_21 == 0)
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+x_22 = l_Lean_moduleNameOfFileName___lambda__2___closed__1;
+x_23 = lean_string_append(x_22, x_1);
+lean_dec(x_1);
+x_24 = l_Lean_moduleNameOfFileName___lambda__2___closed__2;
+x_25 = lean_string_append(x_23, x_24);
+x_26 = lean_string_append(x_25, x_19);
+lean_dec(x_19);
+x_27 = l_ULift_HasRepr___rarg___closed__2;
+x_28 = lean_string_append(x_26, x_27);
+x_29 = lean_alloc_ctor(18, 1, 0);
+lean_ctor_set(x_29, 0, x_28);
+x_30 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_30, 0, x_29);
+lean_ctor_set(x_30, 1, x_20);
+return x_30;
+}
+else
+{
+lean_object* x_31; lean_object* x_32; 
+x_31 = lean_box(0);
+x_32 = l_Lean_moduleNameOfFileName___lambda__1(x_19, x_1, x_31, x_20);
+lean_dec(x_19);
+return x_32;
+}
+}
+}
+else
+{
+uint8_t x_33; 
+lean_dec(x_1);
+x_33 = !lean_is_exclusive(x_4);
+if (x_33 == 0)
+{
+return x_4;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_34 = lean_ctor_get(x_4, 0);
+x_35 = lean_ctor_get(x_4, 1);
+lean_inc(x_35);
+lean_inc(x_34);
+lean_dec(x_4);
+x_36 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_36, 0, x_34);
+lean_ctor_set(x_36, 1, x_35);
+return x_36;
+}
+}
+}
+}
 lean_object* lean_module_name_of_file(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -1142,287 +1574,100 @@ lean_object* x_4;
 x_4 = l_Lean_realPathNormalized(x_1, x_3);
 if (lean_obj_tag(x_4) == 0)
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_4, 0);
 lean_inc(x_5);
 x_6 = lean_ctor_get(x_4, 1);
 lean_inc(x_6);
 lean_dec(x_4);
-if (lean_obj_tag(x_2) == 0)
+x_7 = lean_io_current_dir(x_6);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_69; 
-x_69 = lean_io_current_dir(x_6);
-if (lean_obj_tag(x_69) == 0)
-{
-lean_object* x_70; lean_object* x_71; 
-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_7 = x_70;
-x_8 = x_71;
-goto block_68;
+lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+x_8 = lean_ctor_get(x_7, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_7, 1);
+lean_inc(x_9);
+lean_dec(x_7);
+x_10 = l_Lean_moduleNameOfFileName___lambda__2(x_5, x_8, x_9);
+return x_10;
 }
 else
 {
-uint8_t x_72; 
+uint8_t x_11; 
 lean_dec(x_5);
-x_72 = !lean_is_exclusive(x_69);
-if (x_72 == 0)
+x_11 = !lean_is_exclusive(x_7);
+if (x_11 == 0)
 {
-return x_69;
+return x_7;
 }
 else
 {
-lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_73 = lean_ctor_get(x_69, 0);
-x_74 = lean_ctor_get(x_69, 1);
-lean_inc(x_74);
-lean_inc(x_73);
-lean_dec(x_69);
-x_75 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_75, 0, x_73);
-lean_ctor_set(x_75, 1, x_74);
-return x_75;
+lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+x_12 = lean_ctor_get(x_7, 0);
+x_13 = lean_ctor_get(x_7, 1);
+lean_inc(x_13);
+lean_inc(x_12);
+lean_dec(x_7);
+x_14 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_14, 0, x_12);
+lean_ctor_set(x_14, 1, x_13);
+return x_14;
 }
 }
 }
 else
 {
-lean_object* x_76; 
-x_76 = lean_ctor_get(x_2, 0);
-lean_inc(x_76);
+lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+x_15 = lean_ctor_get(x_4, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_4, 1);
+lean_inc(x_16);
+lean_dec(x_4);
+x_17 = lean_ctor_get(x_2, 0);
+lean_inc(x_17);
 lean_dec(x_2);
-x_7 = x_76;
-x_8 = x_6;
-goto block_68;
-}
-block_68:
-{
-lean_object* x_9; 
-x_9 = l_Lean_realPathNormalized(x_7, x_8);
-if (lean_obj_tag(x_9) == 0)
-{
-lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; 
-x_10 = lean_ctor_get(x_9, 0);
-lean_inc(x_10);
-x_11 = lean_ctor_get(x_9, 1);
-lean_inc(x_11);
-if (lean_is_exclusive(x_9)) {
- lean_ctor_release(x_9, 0);
- lean_ctor_release(x_9, 1);
- x_12 = x_9;
-} else {
- lean_dec_ref(x_9);
- x_12 = lean_box(0);
-}
-x_13 = l_String_isPrefixOf(x_10, x_5);
-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; 
-x_14 = l_Lean_moduleNameOfFileName___closed__1;
-x_15 = lean_string_append(x_14, x_5);
-lean_dec(x_5);
-x_16 = l_Lean_moduleNameOfFileName___closed__2;
-x_17 = lean_string_append(x_15, x_16);
-x_18 = lean_string_append(x_17, x_10);
-lean_dec(x_10);
-x_19 = l_ULift_HasRepr___rarg___closed__2;
-x_20 = lean_string_append(x_18, x_19);
-x_21 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_21, 0, x_20);
-if (lean_is_scalar(x_12)) {
- x_22 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_22 = x_12;
- lean_ctor_set_tag(x_22, 1);
-}
-lean_ctor_set(x_22, 0, x_21);
-lean_ctor_set(x_22, 1, x_11);
-return x_22;
-}
-else
-{
-lean_object* x_23; lean_object* x_24; lean_object* x_25; uint32_t x_26; uint32_t x_27; uint8_t x_28; uint32_t x_29; uint8_t x_30; 
-x_23 = lean_string_length(x_10);
-lean_dec(x_10);
-lean_inc(x_5);
-x_24 = l_String_drop(x_5, x_23);
-x_25 = lean_unsigned_to_nat(0u);
-x_26 = lean_string_utf8_get(x_24, x_25);
-x_27 = l_System_FilePath_pathSeparator;
-x_28 = x_26 == x_27;
-x_29 = 46;
-if (x_28 == 0)
-{
-uint8_t x_62; 
-x_62 = 0;
-x_30 = x_62;
-goto block_61;
-}
-else
-{
-uint8_t x_63; 
-x_63 = 1;
-x_30 = x_63;
-goto block_61;
-}
-block_61:
-{
-if (x_30 == 0)
-{
-lean_object* x_31; 
-x_31 = l_String_revPosOf(x_24, x_29);
-if (lean_obj_tag(x_31) == 0)
-{
-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_dec(x_24);
-x_32 = l_Lean_moduleNameOfFileName___closed__3;
-x_33 = lean_string_append(x_32, x_5);
-lean_dec(x_5);
-x_34 = l_Lean_moduleNameOfFileName___closed__4;
-x_35 = lean_string_append(x_33, x_34);
-x_36 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_36, 0, x_35);
-if (lean_is_scalar(x_12)) {
- x_37 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_37 = x_12;
- lean_ctor_set_tag(x_37, 1);
-}
-lean_ctor_set(x_37, 0, x_36);
-lean_ctor_set(x_37, 1, x_11);
-return x_37;
-}
-else
-{
-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_dec(x_5);
-x_38 = lean_ctor_get(x_31, 0);
-lean_inc(x_38);
-lean_dec(x_31);
-x_39 = lean_string_utf8_extract(x_24, x_25, x_38);
-lean_dec(x_38);
-lean_dec(x_24);
-x_40 = l___private_Lean_Util_Path_1__pathSep;
-x_41 = l_String_splitOn(x_39, x_40);
-x_42 = lean_box(0);
-x_43 = l_List_foldl___main___at_Lean_moduleNameOfFileName___spec__1(x_42, x_41);
-if (lean_is_scalar(x_12)) {
- x_44 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_44 = x_12;
-}
-lean_ctor_set(x_44, 0, x_43);
-lean_ctor_set(x_44, 1, x_11);
-return x_44;
+x_18 = l_Lean_moduleNameOfFileName___lambda__2(x_15, x_17, x_16);
+return x_18;
 }
 }
 else
 {
-lean_object* x_45; lean_object* x_46; lean_object* x_47; 
-x_45 = lean_unsigned_to_nat(1u);
-x_46 = l_String_drop(x_24, x_45);
-x_47 = l_String_revPosOf(x_46, x_29);
-if (lean_obj_tag(x_47) == 0)
-{
-lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
-lean_dec(x_46);
-x_48 = l_Lean_moduleNameOfFileName___closed__3;
-x_49 = lean_string_append(x_48, x_5);
-lean_dec(x_5);
-x_50 = l_Lean_moduleNameOfFileName___closed__4;
-x_51 = lean_string_append(x_49, x_50);
-x_52 = lean_alloc_ctor(18, 1, 0);
-lean_ctor_set(x_52, 0, x_51);
-if (lean_is_scalar(x_12)) {
- x_53 = lean_alloc_ctor(1, 2, 0);
-} else {
- x_53 = x_12;
- lean_ctor_set_tag(x_53, 1);
-}
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_11);
-return x_53;
-}
-else
-{
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
-lean_dec(x_5);
-x_54 = lean_ctor_get(x_47, 0);
-lean_inc(x_54);
-lean_dec(x_47);
-x_55 = lean_string_utf8_extract(x_46, x_25, x_54);
-lean_dec(x_54);
-lean_dec(x_46);
-x_56 = l___private_Lean_Util_Path_1__pathSep;
-x_57 = l_String_splitOn(x_55, x_56);
-x_58 = lean_box(0);
-x_59 = l_List_foldl___main___at_Lean_moduleNameOfFileName___spec__1(x_58, x_57);
-if (lean_is_scalar(x_12)) {
- x_60 = lean_alloc_ctor(0, 2, 0);
-} else {
- x_60 = x_12;
-}
-lean_ctor_set(x_60, 0, x_59);
-lean_ctor_set(x_60, 1, x_11);
-return x_60;
-}
-}
-}
-}
-}
-else
-{
-uint8_t x_64; 
-lean_dec(x_5);
-x_64 = !lean_is_exclusive(x_9);
-if (x_64 == 0)
-{
-return x_9;
-}
-else
-{
-lean_object* x_65; lean_object* x_66; lean_object* x_67; 
-x_65 = lean_ctor_get(x_9, 0);
-x_66 = lean_ctor_get(x_9, 1);
-lean_inc(x_66);
-lean_inc(x_65);
-lean_dec(x_9);
-x_67 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_67, 0, x_65);
-lean_ctor_set(x_67, 1, x_66);
-return x_67;
-}
-}
-}
-}
-else
-{
-uint8_t x_77; 
+uint8_t x_19; 
 lean_dec(x_2);
-x_77 = !lean_is_exclusive(x_4);
-if (x_77 == 0)
+x_19 = !lean_is_exclusive(x_4);
+if (x_19 == 0)
 {
 return x_4;
 }
 else
 {
-lean_object* x_78; lean_object* x_79; lean_object* x_80; 
-x_78 = lean_ctor_get(x_4, 0);
-x_79 = lean_ctor_get(x_4, 1);
-lean_inc(x_79);
-lean_inc(x_78);
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+x_20 = lean_ctor_get(x_4, 0);
+x_21 = lean_ctor_get(x_4, 1);
+lean_inc(x_21);
+lean_inc(x_20);
 lean_dec(x_4);
-x_80 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_80, 0, x_78);
-lean_ctor_set(x_80, 1, x_79);
-return x_80;
+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_object* l_Lean_moduleNameOfFileName___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Lean_moduleNameOfFileName___lambda__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_1);
+return x_5;
+}
+}
 lean_object* initialize_Init(lean_object*);
 lean_object* initialize_Lean_Data_Name(lean_object*);
 static bool _G_initialized = false;
@@ -1436,8 +1681,8 @@ lean_dec_ref(res);
 res = initialize_Lean_Data_Name(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l___private_Lean_Util_Path_1__pathSep = _init_l___private_Lean_Util_Path_1__pathSep();
-lean_mark_persistent(l___private_Lean_Util_Path_1__pathSep);
+l___private_Lean_Util_Path_0__Lean_pathSep = _init_l___private_Lean_Util_Path_0__Lean_pathSep();
+lean_mark_persistent(l___private_Lean_Util_Path_0__Lean_pathSep);
 res = l_Lean_mkSearchPathRef(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 l_Lean_searchPathRef = lean_io_result_get_value(res);
@@ -1460,24 +1705,26 @@ l_Lean_getBuiltinSearchPath___closed__8 = _init_l_Lean_getBuiltinSearchPath___cl
 lean_mark_persistent(l_Lean_getBuiltinSearchPath___closed__8);
 l_Lean_addSearchPathFromEnv___closed__1 = _init_l_Lean_addSearchPathFromEnv___closed__1();
 lean_mark_persistent(l_Lean_addSearchPathFromEnv___closed__1);
-l_Lean_modPathToFilePath___main___closed__1 = _init_l_Lean_modPathToFilePath___main___closed__1();
-lean_mark_persistent(l_Lean_modPathToFilePath___main___closed__1);
-l_Lean_modPathToFilePath___main___closed__2 = _init_l_Lean_modPathToFilePath___main___closed__2();
-lean_mark_persistent(l_Lean_modPathToFilePath___main___closed__2);
-l_Lean_modPathToFilePath___main___closed__3 = _init_l_Lean_modPathToFilePath___main___closed__3();
-lean_mark_persistent(l_Lean_modPathToFilePath___main___closed__3);
+l_Lean_modPathToFilePath___closed__1 = _init_l_Lean_modPathToFilePath___closed__1();
+lean_mark_persistent(l_Lean_modPathToFilePath___closed__1);
+l_Lean_modPathToFilePath___closed__2 = _init_l_Lean_modPathToFilePath___closed__2();
+lean_mark_persistent(l_Lean_modPathToFilePath___closed__2);
+l_Lean_modPathToFilePath___closed__3 = _init_l_Lean_modPathToFilePath___closed__3();
+lean_mark_persistent(l_Lean_modPathToFilePath___closed__3);
+l_Lean_modPathToFilePath___closed__4 = _init_l_Lean_modPathToFilePath___closed__4();
+lean_mark_persistent(l_Lean_modPathToFilePath___closed__4);
 l_Lean_findOLean___closed__1 = _init_l_Lean_findOLean___closed__1();
 lean_mark_persistent(l_Lean_findOLean___closed__1);
 l_Lean_findOLean___closed__2 = _init_l_Lean_findOLean___closed__2();
 lean_mark_persistent(l_Lean_findOLean___closed__2);
-l_Lean_moduleNameOfFileName___closed__1 = _init_l_Lean_moduleNameOfFileName___closed__1();
-lean_mark_persistent(l_Lean_moduleNameOfFileName___closed__1);
-l_Lean_moduleNameOfFileName___closed__2 = _init_l_Lean_moduleNameOfFileName___closed__2();
-lean_mark_persistent(l_Lean_moduleNameOfFileName___closed__2);
-l_Lean_moduleNameOfFileName___closed__3 = _init_l_Lean_moduleNameOfFileName___closed__3();
-lean_mark_persistent(l_Lean_moduleNameOfFileName___closed__3);
-l_Lean_moduleNameOfFileName___closed__4 = _init_l_Lean_moduleNameOfFileName___closed__4();
-lean_mark_persistent(l_Lean_moduleNameOfFileName___closed__4);
+l_Lean_moduleNameOfFileName___lambda__1___closed__1 = _init_l_Lean_moduleNameOfFileName___lambda__1___closed__1();
+lean_mark_persistent(l_Lean_moduleNameOfFileName___lambda__1___closed__1);
+l_Lean_moduleNameOfFileName___lambda__1___closed__2 = _init_l_Lean_moduleNameOfFileName___lambda__1___closed__2();
+lean_mark_persistent(l_Lean_moduleNameOfFileName___lambda__1___closed__2);
+l_Lean_moduleNameOfFileName___lambda__2___closed__1 = _init_l_Lean_moduleNameOfFileName___lambda__2___closed__1();
+lean_mark_persistent(l_Lean_moduleNameOfFileName___lambda__2___closed__1);
+l_Lean_moduleNameOfFileName___lambda__2___closed__2 = _init_l_Lean_moduleNameOfFileName___lambda__2___closed__2();
+lean_mark_persistent(l_Lean_moduleNameOfFileName___lambda__2___closed__2);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Util/RecDepth.c b/stage0/stdlib/Lean/Util/RecDepth.c
index c8fb4c579d..70fe0dd9c8 100644
--- a/stage0/stdlib/Lean/Util/RecDepth.c
+++ b/stage0/stdlib/Lean/Util/RecDepth.c
@@ -13,18 +13,18 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__3;
 lean_object* l_Lean_getMaxRecDepth___boxed(lean_object*);
 lean_object* l_Lean_getMaxRecDepth___closed__2;
 lean_object* l_Lean_getMaxRecDepth___closed__1;
 extern lean_object* l_String_splitAux___main___closed__1;
-lean_object* l_Lean_maxRecDepth(lean_object*);
-lean_object* l_Lean_maxRecDepth___closed__3;
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
 lean_object* l_Lean_KVMap_getNat(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_getMaxRecDepth(lean_object*);
+lean_object* l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__2;
+lean_object* l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__1;
 lean_object* lean_register_option(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_maxRecDepth___closed__2;
-lean_object* l_Lean_maxRecDepth___closed__1;
+lean_object* l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9_(lean_object*);
 extern lean_object* l_Lean_defaultMaxRecDepth;
 static lean_object* _init_l_Lean_getMaxRecDepth___closed__1() {
 _start:
@@ -63,7 +63,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_maxRecDepth___closed__1() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -73,7 +73,7 @@ lean_ctor_set(x_2, 0, x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Lean_maxRecDepth___closed__2() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__2() {
 _start:
 {
 lean_object* x_1; 
@@ -81,13 +81,13 @@ x_1 = lean_mk_string("maximum recursion depth for many Lean procedures");
 return x_1;
 }
 }
-static lean_object* _init_l_Lean_maxRecDepth___closed__3() {
+static lean_object* _init_l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__3() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; 
-x_1 = l_Lean_maxRecDepth___closed__1;
+x_1 = l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__1;
 x_2 = l_String_splitAux___main___closed__1;
-x_3 = l_Lean_maxRecDepth___closed__2;
+x_3 = l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____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);
@@ -95,12 +95,12 @@ lean_ctor_set(x_4, 2, x_3);
 return x_4;
 }
 }
-lean_object* l_Lean_maxRecDepth(lean_object* x_1) {
+lean_object* l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9_(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = l_Lean_getMaxRecDepth___closed__2;
-x_3 = l_Lean_maxRecDepth___closed__3;
+x_3 = l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__3;
 x_4 = lean_register_option(x_2, x_3, x_1);
 return x_4;
 }
@@ -122,13 +122,13 @@ l_Lean_getMaxRecDepth___closed__1 = _init_l_Lean_getMaxRecDepth___closed__1();
 lean_mark_persistent(l_Lean_getMaxRecDepth___closed__1);
 l_Lean_getMaxRecDepth___closed__2 = _init_l_Lean_getMaxRecDepth___closed__2();
 lean_mark_persistent(l_Lean_getMaxRecDepth___closed__2);
-l_Lean_maxRecDepth___closed__1 = _init_l_Lean_maxRecDepth___closed__1();
-lean_mark_persistent(l_Lean_maxRecDepth___closed__1);
-l_Lean_maxRecDepth___closed__2 = _init_l_Lean_maxRecDepth___closed__2();
-lean_mark_persistent(l_Lean_maxRecDepth___closed__2);
-l_Lean_maxRecDepth___closed__3 = _init_l_Lean_maxRecDepth___closed__3();
-lean_mark_persistent(l_Lean_maxRecDepth___closed__3);
-res = l_Lean_maxRecDepth(lean_io_mk_world());
+l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__1 = _init_l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__1();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__1);
+l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__2 = _init_l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__2();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__2);
+l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__3 = _init_l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__3();
+lean_mark_persistent(l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9____closed__3);
+res = l_Lean_initFn____x40_Lean_Util_RecDepth___hyg_9_(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 return lean_io_result_mk_ok(lean_box(0));
diff --git a/stage0/stdlib/Lean/Util/Recognizers.c b/stage0/stdlib/Lean/Util/Recognizers.c
index 243217ccb4..0a99569f9b 100644
--- a/stage0/stdlib/Lean/Util/Recognizers.c
+++ b/stage0/stdlib/Lean/Util/Recognizers.c
@@ -16,17 +16,21 @@ extern "C" {
 lean_object* l_List_reverse___rarg(lean_object*);
 lean_object* l_Lean_Expr_eq_x3f___closed__1;
 lean_object* l_Lean_Expr_iff_x3f(lean_object*);
+lean_object* l_Lean_Expr_listLitAux_match__1(lean_object*);
 lean_object* l_Lean_Expr_eq_x3f___closed__2;
 lean_object* l_Lean_Expr_eq_x3f___boxed(lean_object*);
 lean_object* l___private_Lean_Expr_3__getAppArgsAux___main(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f_match__1(lean_object*);
 extern lean_object* l___private_Init_LeanInit_14__quoteList___main___rarg___closed__7;
 extern lean_object* l_Array_empty___closed__1;
 extern lean_object* l_Lean_Array_hasQuote___rarg___closed__2;
 lean_object* lean_environment_find(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_constructorApp_x3f(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__1(lean_object*);
 lean_object* l_Lean_Expr_appFn_x21(lean_object*);
 lean_object* lean_array_push(lean_object*, lean_object*);
 extern lean_object* l_Lean_Prod_hasQuote___rarg___closed__2;
+lean_object* l_Lean_Expr_arrayLit_x3f_match__1(lean_object*);
 lean_object* l_Lean_Expr_getAppFn___main(lean_object*);
 extern lean_object* l_Lean_Expr_getAppArgs___closed__1;
 lean_object* l_Lean_Expr_app4_x3f(lean_object*, lean_object*);
@@ -35,14 +39,17 @@ lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_getAppNumArgsAux___main(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f___closed__4;
-lean_object* l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_listLit_x3f(lean_object*);
 lean_object* lean_nat_sub(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_heq_x3f___closed__2;
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_iff_x3f___closed__2;
+lean_object* l_Lean_Expr_listLitAux_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_heq_x3f(lean_object*);
+lean_object* l_Lean_Expr_arrayLit_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_app4_x3f___boxed(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__3___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_eq_x3f(lean_object*);
 lean_object* l_Lean_Expr_iff_x3f___boxed(lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
@@ -52,28 +59,38 @@ lean_object* l_Lean_Expr_app2_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f___closed__2;
 extern lean_object* l_Lean_Literal_type___closed__2;
 lean_object* l_Lean_Expr_listLitAux(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_constructorApp_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(lean_object*, lean_object*);
 uint8_t l_Lean_Expr_isAppOfArity___main(lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_listLitAux___main(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_app3_x3f(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_heq_x3f___closed__1;
 lean_object* l_Lean_Expr_heq_x3f___boxed(lean_object*);
 lean_object* l_Lean_Expr_app1_x3f___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_app2_x3f___boxed(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_arrow_x3f(lean_object*);
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__3(lean_object*);
+lean_object* l_Lean_Expr_constructorApp_x3f_match__1(lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f___closed__1;
 lean_object* l_Lean_Expr_app1_x3f(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_arrow_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_arrayLit_x3f___boxed(lean_object*);
 lean_object* l_Lean_Expr_arrayLit_x3f(lean_object*);
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__2(lean_object*);
 uint8_t l_Lean_Expr_hasLooseBVars(lean_object*);
 lean_object* l_Lean_Expr_arrow_x3f___boxed(lean_object*);
 lean_object* lean_mk_array(lean_object*, lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f___closed__3;
+lean_object* l_Lean_Expr_constructorApp_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_constructorApp_x3f_match__2(lean_object*);
 lean_object* l_Lean_Expr_prod_x3f(lean_object*);
 lean_object* l_Lean_Expr_prod_x3f___boxed(lean_object*);
 extern lean_object* l_Lean_mkOptionalNode___closed__2;
 lean_object* l_Lean_mkNatLit(lean_object*);
+lean_object* l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l___private_Init_LeanInit_14__quoteList___main___rarg___closed__4;
+lean_object* l_Lean_Expr_arrow_x3f_match__1(lean_object*);
 lean_object* l_Lean_Expr_isConstructorApp_x3f(lean_object*, lean_object*);
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_app1_x3f(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -424,6 +441,42 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_Lean_Expr_arrow_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 7)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; uint64_t x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_3);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get(x_1, 2);
+lean_inc(x_6);
+x_7 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_8 = lean_box_uint64(x_7);
+x_9 = lean_apply_4(x_2, x_4, x_5, x_6, x_8);
+return x_9;
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_2);
+x_10 = lean_apply_1(x_3, x_1);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_Expr_arrow_x3f_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_arrow_x3f_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Expr_arrow_x3f(lean_object* x_1) {
 _start:
 {
@@ -469,7 +522,23 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Lean_Expr_listLitAux___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Lean_Expr_listLitAux_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_2(x_3, x_1, x_2);
+return x_4;
+}
+}
+lean_object* l_Lean_Expr_listLitAux_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_listLitAux_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Expr_listLitAux(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; lean_object* x_4; uint8_t x_5; 
@@ -521,72 +590,70 @@ return x_18;
 }
 }
 }
-lean_object* l_Lean_Expr_listLitAux(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Lean_Expr_listLitAux___main(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Lean_Expr_listLit_x3f(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = lean_box(0);
-x_3 = l_Lean_Expr_listLitAux___main(x_1, x_2);
+x_3 = l_Lean_Expr_listLitAux(x_1, x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Expr_arrayLit_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+lean_dec(x_6);
+x_9 = lean_apply_2(x_2, x_7, x_8);
+return x_9;
+}
+}
+}
+lean_object* l_Lean_Expr_arrayLit_x3f_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_arrayLit_x3f_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Expr_arrayLit_x3f(lean_object* x_1) {
 _start:
 {
-lean_object* x_2; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
-x_8 = l_Lean_Array_hasQuote___rarg___closed__2;
-x_9 = lean_unsigned_to_nat(2u);
-x_10 = l_Lean_Expr_isAppOfArity___main(x_1, x_8, x_9);
-if (x_10 == 0)
+lean_object* x_2; lean_object* x_3; uint8_t x_4; 
+x_2 = l_Lean_Array_hasQuote___rarg___closed__2;
+x_3 = lean_unsigned_to_nat(2u);
+x_4 = l_Lean_Expr_isAppOfArity___main(x_1, x_2, x_3);
+if (x_4 == 0)
 {
-lean_object* x_11; 
-x_11 = lean_box(0);
-x_2 = x_11;
-goto block_7;
+lean_object* x_5; 
+x_5 = lean_box(0);
+return x_5;
 }
 else
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_12 = l_Lean_Expr_appFn_x21(x_1);
-x_13 = l_Lean_Expr_appArg_x21(x_12);
-lean_dec(x_12);
-x_14 = l_Lean_Expr_appArg_x21(x_1);
-x_15 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_15, 0, x_13);
-lean_ctor_set(x_15, 1, x_14);
-x_16 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_16, 0, x_15);
-x_2 = x_16;
-goto block_7;
-}
-block_7:
-{
-if (lean_obj_tag(x_2) == 0)
-{
-lean_object* x_3; 
-x_3 = lean_box(0);
-return x_3;
-}
-else
-{
-lean_object* x_4; lean_object* x_5; lean_object* x_6; 
-x_4 = lean_ctor_get(x_2, 0);
-lean_inc(x_4);
-lean_dec(x_2);
-x_5 = lean_ctor_get(x_4, 1);
-lean_inc(x_5);
-lean_dec(x_4);
-x_6 = l_Lean_Expr_listLit_x3f(x_5);
-return x_6;
-}
+lean_object* x_6; lean_object* x_7; 
+x_6 = l_Lean_Expr_appArg_x21(x_1);
+x_7 = l_Lean_Expr_listLit_x3f(x_6);
+return x_7;
 }
 }
 }
@@ -637,7 +704,52 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_1, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 6)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+lean_dec(x_5);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_5);
+lean_dec(x_2);
+x_8 = lean_apply_1(x_3, x_1);
+return x_8;
+}
+}
+}
+}
+lean_object* l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
@@ -701,6 +813,118 @@ return x_12;
 }
 }
 }
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_isConstructorApp_x3f_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 4)
+{
+lean_object* x_4; lean_object* x_5; uint64_t x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_7 = lean_box_uint64(x_6);
+x_8 = lean_apply_3(x_2, x_4, x_5, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+}
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_isConstructorApp_x3f_match__2___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 9)
+{
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+if (lean_obj_tag(x_4) == 0)
+{
+uint64_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_5 = lean_ctor_get_uint64(x_1, sizeof(void*)*1);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_4, 0);
+lean_inc(x_6);
+lean_dec(x_4);
+x_7 = lean_box_uint64(x_5);
+x_8 = lean_apply_2(x_2, x_6, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_2);
+x_10 = lean_apply_1(x_3, x_1);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_Expr_isConstructorApp_x3f_match__3(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_isConstructorApp_x3f_match__3___rarg), 3, 0);
+return x_2;
+}
+}
 static lean_object* _init_l_Lean_Expr_isConstructorApp_x3f___closed__1() {
 _start:
 {
@@ -754,14 +978,14 @@ if (x_6 == 0)
 {
 lean_object* x_7; lean_object* x_8; 
 x_7 = l_Lean_Expr_isConstructorApp_x3f___closed__2;
-x_8 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_7);
+x_8 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_7);
 return x_8;
 }
 else
 {
 lean_object* x_9; lean_object* x_10; 
 x_9 = l_Lean_Expr_isConstructorApp_x3f___closed__4;
-x_10 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_9);
+x_10 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_9);
 return x_10;
 }
 }
@@ -775,105 +999,183 @@ lean_object* x_12; lean_object* x_13;
 x_12 = lean_ctor_get(x_11, 0);
 lean_inc(x_12);
 lean_dec(x_11);
-x_13 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_12);
+x_13 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_12);
 if (lean_obj_tag(x_13) == 0)
 {
-return x_13;
+lean_object* x_14; 
+x_14 = lean_box(0);
+return x_14;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-x_15 = lean_ctor_get(x_14, 3);
-lean_inc(x_15);
-x_16 = lean_ctor_get(x_14, 4);
-lean_inc(x_16);
-lean_dec(x_14);
-x_17 = lean_nat_add(x_15, x_16);
-lean_dec(x_16);
-lean_dec(x_15);
-x_18 = lean_unsigned_to_nat(0u);
-x_19 = l_Lean_Expr_getAppNumArgsAux___main(x_2, x_18);
-x_20 = lean_nat_dec_eq(x_17, x_19);
-lean_dec(x_19);
+uint8_t x_15; 
+x_15 = !lean_is_exclusive(x_13);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; 
+x_16 = lean_ctor_get(x_13, 0);
+x_17 = lean_ctor_get(x_16, 3);
+lean_inc(x_17);
+x_18 = lean_ctor_get(x_16, 4);
+lean_inc(x_18);
+x_19 = lean_nat_add(x_17, x_18);
+lean_dec(x_18);
 lean_dec(x_17);
-if (x_20 == 0)
-{
-lean_object* x_21; 
-lean_dec(x_13);
-x_21 = lean_box(0);
-return x_21;
-}
-else
-{
-return x_13;
-}
-}
-}
-else
-{
-lean_object* x_22; 
-lean_dec(x_11);
-lean_dec(x_1);
-x_22 = lean_box(0);
-return x_22;
-}
-}
-}
-else
+x_20 = lean_unsigned_to_nat(0u);
+x_21 = l_Lean_Expr_getAppNumArgsAux___main(x_2, x_20);
+x_22 = lean_nat_dec_eq(x_19, x_21);
+lean_dec(x_21);
+lean_dec(x_19);
+if (x_22 == 0)
 {
 lean_object* x_23; 
-x_23 = l_Lean_Expr_getAppFn___main(x_2);
-if (lean_obj_tag(x_23) == 4)
-{
-lean_object* x_24; lean_object* x_25; 
-x_24 = lean_ctor_get(x_23, 0);
-lean_inc(x_24);
-lean_dec(x_23);
-x_25 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_24);
-if (lean_obj_tag(x_25) == 0)
-{
-return x_25;
+lean_free_object(x_13);
+lean_dec(x_16);
+x_23 = lean_box(0);
+return x_23;
 }
 else
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-x_26 = lean_ctor_get(x_25, 0);
+return x_13;
+}
+}
+else
+{
+lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_24 = lean_ctor_get(x_13, 0);
+lean_inc(x_24);
+lean_dec(x_13);
+x_25 = lean_ctor_get(x_24, 3);
+lean_inc(x_25);
+x_26 = lean_ctor_get(x_24, 4);
 lean_inc(x_26);
-x_27 = lean_ctor_get(x_26, 3);
-lean_inc(x_27);
-x_28 = lean_ctor_get(x_26, 4);
-lean_inc(x_28);
+x_27 = lean_nat_add(x_25, x_26);
 lean_dec(x_26);
-x_29 = lean_nat_add(x_27, x_28);
-lean_dec(x_28);
-lean_dec(x_27);
-x_30 = lean_unsigned_to_nat(0u);
-x_31 = l_Lean_Expr_getAppNumArgsAux___main(x_2, x_30);
-x_32 = lean_nat_dec_eq(x_29, x_31);
-lean_dec(x_31);
+lean_dec(x_25);
+x_28 = lean_unsigned_to_nat(0u);
+x_29 = l_Lean_Expr_getAppNumArgsAux___main(x_2, x_28);
+x_30 = lean_nat_dec_eq(x_27, x_29);
 lean_dec(x_29);
-if (x_32 == 0)
+lean_dec(x_27);
+if (x_30 == 0)
+{
+lean_object* x_31; 
+lean_dec(x_24);
+x_31 = lean_box(0);
+return x_31;
+}
+else
+{
+lean_object* x_32; 
+x_32 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_32, 0, x_24);
+return x_32;
+}
+}
+}
+}
+else
 {
 lean_object* x_33; 
-lean_dec(x_25);
+lean_dec(x_11);
+lean_dec(x_1);
 x_33 = lean_box(0);
 return x_33;
 }
-else
-{
-return x_25;
-}
 }
 }
 else
 {
 lean_object* x_34; 
-lean_dec(x_23);
+x_34 = l_Lean_Expr_getAppFn___main(x_2);
+if (lean_obj_tag(x_34) == 4)
+{
+lean_object* x_35; lean_object* x_36; 
+x_35 = lean_ctor_get(x_34, 0);
+lean_inc(x_35);
+lean_dec(x_34);
+x_36 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_35);
+if (lean_obj_tag(x_36) == 0)
+{
+lean_object* x_37; 
+x_37 = lean_box(0);
+return x_37;
+}
+else
+{
+uint8_t x_38; 
+x_38 = !lean_is_exclusive(x_36);
+if (x_38 == 0)
+{
+lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_39 = lean_ctor_get(x_36, 0);
+x_40 = lean_ctor_get(x_39, 3);
+lean_inc(x_40);
+x_41 = lean_ctor_get(x_39, 4);
+lean_inc(x_41);
+x_42 = lean_nat_add(x_40, x_41);
+lean_dec(x_41);
+lean_dec(x_40);
+x_43 = lean_unsigned_to_nat(0u);
+x_44 = l_Lean_Expr_getAppNumArgsAux___main(x_2, x_43);
+x_45 = lean_nat_dec_eq(x_42, x_44);
+lean_dec(x_44);
+lean_dec(x_42);
+if (x_45 == 0)
+{
+lean_object* x_46; 
+lean_free_object(x_36);
+lean_dec(x_39);
+x_46 = lean_box(0);
+return x_46;
+}
+else
+{
+return x_36;
+}
+}
+else
+{
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_47 = lean_ctor_get(x_36, 0);
+lean_inc(x_47);
+lean_dec(x_36);
+x_48 = lean_ctor_get(x_47, 3);
+lean_inc(x_48);
+x_49 = lean_ctor_get(x_47, 4);
+lean_inc(x_49);
+x_50 = lean_nat_add(x_48, x_49);
+lean_dec(x_49);
+lean_dec(x_48);
+x_51 = lean_unsigned_to_nat(0u);
+x_52 = l_Lean_Expr_getAppNumArgsAux___main(x_2, x_51);
+x_53 = lean_nat_dec_eq(x_50, x_52);
+lean_dec(x_52);
+lean_dec(x_50);
+if (x_53 == 0)
+{
+lean_object* x_54; 
+lean_dec(x_47);
+x_54 = lean_box(0);
+return x_54;
+}
+else
+{
+lean_object* x_55; 
+x_55 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_55, 0, x_47);
+return x_55;
+}
+}
+}
+}
+else
+{
+lean_object* x_56; 
+lean_dec(x_34);
 lean_dec(x_1);
-x_34 = lean_box(0);
-return x_34;
+x_56 = lean_box(0);
+return x_56;
 }
 }
 }
@@ -887,6 +1189,87 @@ lean_dec(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Expr_constructorApp_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 4)
+{
+lean_object* x_4; lean_object* x_5; uint64_t x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+x_6 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_7 = lean_box_uint64(x_6);
+x_8 = lean_apply_3(x_2, x_4, x_5, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+}
+lean_object* l_Lean_Expr_constructorApp_x3f_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_constructorApp_x3f_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l_Lean_Expr_constructorApp_x3f_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 9)
+{
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+if (lean_obj_tag(x_4) == 0)
+{
+uint64_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_5 = lean_ctor_get_uint64(x_1, sizeof(void*)*1);
+lean_dec(x_1);
+x_6 = lean_ctor_get(x_4, 0);
+lean_inc(x_6);
+lean_dec(x_4);
+x_7 = lean_box_uint64(x_5);
+x_8 = lean_apply_2(x_2, x_6, x_7);
+return x_8;
+}
+else
+{
+lean_object* x_9; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_9 = lean_apply_1(x_3, x_1);
+return x_9;
+}
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_2);
+x_10 = lean_apply_1(x_3, x_1);
+return x_10;
+}
+}
+}
+lean_object* l_Lean_Expr_constructorApp_x3f_match__2(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_constructorApp_x3f_match__2___rarg), 3, 0);
+return x_2;
+}
+}
 lean_object* l_Lean_Expr_constructorApp_x3f(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -908,7 +1291,7 @@ if (x_6 == 0)
 {
 lean_object* x_7; lean_object* x_8; 
 x_7 = l_Lean_Expr_isConstructorApp_x3f___closed__2;
-x_8 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_7);
+x_8 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_7);
 if (lean_obj_tag(x_8) == 0)
 {
 lean_object* x_9; 
@@ -962,7 +1345,7 @@ else
 lean_object* x_26; lean_object* x_27; 
 lean_dec(x_4);
 x_26 = l_Lean_Expr_isConstructorApp_x3f___closed__4;
-x_27 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_26);
+x_27 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_26);
 if (lean_obj_tag(x_27) == 0)
 {
 lean_object* x_28; 
@@ -1012,7 +1395,7 @@ lean_object* x_38; lean_object* x_39;
 x_38 = lean_ctor_get(x_37, 0);
 lean_inc(x_38);
 lean_dec(x_37);
-x_39 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_38);
+x_39 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_38);
 if (lean_obj_tag(x_39) == 0)
 {
 lean_object* x_40; 
@@ -1133,7 +1516,7 @@ lean_object* x_73; lean_object* x_74;
 x_73 = lean_ctor_get(x_72, 0);
 lean_inc(x_73);
 lean_dec(x_72);
-x_74 = l___private_Lean_Util_Recognizers_1__getConstructorVal_x3f(x_1, x_73);
+x_74 = l___private_Lean_Util_Recognizers_0__Lean_Expr_getConstructorVal_x3f(x_1, x_73);
 if (lean_obj_tag(x_74) == 0)
 {
 lean_object* x_75; 
diff --git a/stage0/stdlib/Lean/Util/SCC.c b/stage0/stdlib/Lean/Util/SCC.c
index 19bc1128a6..65032fe63e 100644
--- a/stage0/stdlib/Lean/Util/SCC.c
+++ b/stage0/stdlib/Lean/Util/SCC.c
@@ -14,49 +14,161 @@
 extern "C" {
 #endif
 lean_object* l_List_reverse___rarg(lean_object*);
+lean_object* l_Lean_SCC_State_data___default___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_SCC_scc(lean_object*);
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1;
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf(lean_object*);
+lean_object* l_Lean_SCC_Data_index_x3f___default;
 extern lean_object* l_Std_HashMap_inhabited___closed__1;
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_push___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___lambda__1(lean_object*);
 lean_object* l_Lean_SCC_scc___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_1__getDataOf___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf(lean_object*);
+lean_object* l_Lean_SCC_State_data___default(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack(lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___rarg___lambda__1(lean_object*);
-lean_object* l___private_Lean_Util_SCC_8__sccAux(lean_object*);
-lean_object* l___private_Lean_Util_SCC_2__push(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1;
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf_match__1(lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1;
+lean_object* l_Lean_SCC_scc_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SCC_scc_match__1___rarg(lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC(lean_object*);
 lean_object* l_Std_HashMapImp_find_x3f___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg___lambda__1(lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1;
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main(lean_object*);
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___spec__1(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux_match__1(lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1;
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_push(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf_match__1(lean_object*);
+uint8_t l_Lean_SCC_Data_onStack___default;
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SCC_State_stack___default(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Id_Monad;
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_7__addSCC___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_2__push___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SCC_Data_lowlink_x3f___default;
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_StateT_Monad___rarg(lean_object*);
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1(lean_object*);
-lean_object* l___private_Lean_Util_SCC_7__addSCC(lean_object*);
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg___lambda__1(lean_object*, lean_object*);
 lean_object* l_List_forM___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_5__updateLowLinkOf___spec__1(lean_object*);
-lean_object* l___private_Lean_Util_SCC_1__getDataOf(lean_object*);
-lean_object* l___private_Lean_Util_SCC_8__sccAux___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main(lean_object*);
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_5__updateLowLinkOf___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf_match__1(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux(lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1;
+lean_object* l_Lean_SCC_State_sccs___default(lean_object*);
 lean_object* l_Lean_SCC_scc___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_HashMapImp_insert___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf(lean_object*);
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_SCC_scc_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-static lean_object* _init_l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1() {
+lean_object* l_Lean_SCC_State_nextIndex___default;
+static lean_object* _init_l_Lean_SCC_Data_index_x3f___default() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_box(0);
+return x_1;
+}
+}
+static lean_object* _init_l_Lean_SCC_Data_lowlink_x3f___default() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_box(0);
+return x_1;
+}
+}
+static uint8_t _init_l_Lean_SCC_Data_onStack___default() {
+_start:
+{
+uint8_t x_1; 
+x_1 = 0;
+return x_1;
+}
+}
+lean_object* l_Lean_SCC_State_stack___default(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_box(0);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_SCC_State_nextIndex___default() {
+_start:
+{
+lean_object* x_1; 
+x_1 = lean_unsigned_to_nat(0u);
+return x_1;
+}
+}
+lean_object* l_Lean_SCC_State_data___default(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Std_HashMap_inhabited___closed__1;
+return x_4;
+}
+}
+lean_object* l_Lean_SCC_State_data___default___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Lean_SCC_State_data___default(x_1, x_2, x_3);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
+lean_object* l_Lean_SCC_State_sccs___default(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_box(0);
+return x_2;
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+static lean_object* _init_l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; uint8_t x_2; lean_object* x_3; 
@@ -69,7 +181,7 @@ lean_ctor_set_uint8(x_3, sizeof(void*)*2, x_2);
 return x_3;
 }
 }
-lean_object* l___private_Lean_Util_SCC_1__getDataOf___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; lean_object* x_6; 
@@ -80,7 +192,7 @@ lean_dec(x_5);
 if (lean_obj_tag(x_6) == 0)
 {
 lean_object* x_7; lean_object* x_8; 
-x_7 = l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1;
+x_7 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1;
 x_8 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_8, 0, x_7);
 lean_ctor_set(x_8, 1, x_4);
@@ -99,15 +211,15 @@ return x_10;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_1__getDataOf(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_1__getDataOf___rarg), 4, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg), 4, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_2__push___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_push___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -182,15 +294,46 @@ return x_31;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_2__push(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_push(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_2__push___rarg), 4, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_push___rarg), 4, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf_match__1___rarg), 3, 0);
+return x_2;
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 uint8_t x_6; 
@@ -288,15 +431,15 @@ return x_29;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_3__modifyDataOf___rarg), 5, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___rarg), 5, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 uint8_t x_6; 
@@ -394,15 +537,15 @@ return x_29;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1___rarg), 5, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1___rarg), 5, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___rarg___lambda__1(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___lambda__1(lean_object* x_1) {
 _start:
 {
 uint8_t x_2; 
@@ -431,32 +574,87 @@ return x_7;
 }
 }
 }
-static lean_object* _init_l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1() {
+static lean_object* _init_l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_4__resetOnStack___rarg___lambda__1), 1, 0);
+x_1 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___lambda__1), 1, 0);
 return x_1;
 }
 }
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; lean_object* x_6; 
-x_5 = l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1;
-x_6 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1___rarg(x_1, x_2, x_3, x_5, x_4);
+x_5 = l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1;
+x_6 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1___rarg(x_1, x_2, x_3, x_5, x_4);
 return x_6;
 }
 }
-lean_object* l___private_Lean_Util_SCC_4__resetOnStack(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_4__resetOnStack___rarg), 4, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg), 4, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_5__updateLowLinkOf___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_dec(x_5);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_6; 
+lean_dec(x_4);
+x_6 = lean_apply_1(x_3, x_2);
+return x_6;
+}
+else
+{
+lean_object* x_7; 
+lean_dec(x_3);
+x_7 = lean_apply_1(x_4, x_2);
+return x_7;
+}
+}
+else
+{
+lean_dec(x_4);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_8; 
+lean_dec(x_5);
+x_8 = lean_apply_1(x_3, x_1);
+return x_8;
+}
+else
+{
+lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_3);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_ctor_get(x_2, 0);
+lean_inc(x_10);
+lean_dec(x_2);
+x_11 = lean_apply_2(x_5, x_9, x_10);
+return x_11;
+}
+}
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf_match__1___rarg), 5, 0);
+return x_2;
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 uint8_t x_6; 
@@ -554,15 +752,15 @@ return x_29;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_5__updateLowLinkOf___spec__1(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_5__updateLowLinkOf___spec__1___rarg), 5, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___spec__1___rarg), 5, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg___lambda__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg___lambda__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
@@ -737,111 +935,144 @@ return x_33;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg___lambda__1), 2, 1);
+x_6 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg___lambda__1), 2, 1);
 lean_closure_set(x_6, 0, x_4);
-x_7 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_5__updateLowLinkOf___spec__1___rarg(x_1, x_2, x_3, x_6, x_5);
+x_7 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___spec__1___rarg(x_1, x_2, x_3, x_6, x_5);
 return x_7;
 }
 }
-lean_object* l___private_Lean_Util_SCC_5__updateLowLinkOf(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg), 5, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg), 5, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_4);
+x_5 = lean_apply_1(x_3, x_2);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_3(x_4, x_6, x_7, x_2);
+return x_8;
+}
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux_match__1___rarg), 4, 0);
+return x_3;
+}
+}
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 if (lean_obj_tag(x_4) == 0)
 {
-uint8_t x_7; 
+lean_object* x_7; uint8_t x_8; 
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_7 = !lean_is_exclusive(x_6);
-if (x_7 == 0)
+x_7 = lean_box(0);
+x_8 = !lean_is_exclusive(x_6);
+if (x_8 == 0)
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_8 = lean_ctor_get(x_6, 3);
-x_9 = lean_ctor_get(x_6, 0);
-lean_dec(x_9);
-x_10 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_10, 0, x_5);
-lean_ctor_set(x_10, 1, x_8);
-lean_ctor_set(x_6, 3, x_10);
-lean_ctor_set(x_6, 0, x_4);
-x_11 = lean_box(0);
-x_12 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_12, 0, x_11);
-lean_ctor_set(x_12, 1, x_6);
-return x_12;
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_6, 3);
+x_10 = lean_ctor_get(x_6, 0);
+lean_dec(x_10);
+x_11 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_11, 0, x_5);
+lean_ctor_set(x_11, 1, x_9);
+lean_ctor_set(x_6, 3, x_11);
+lean_ctor_set(x_6, 0, x_7);
+x_12 = lean_box(0);
+x_13 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_13, 0, x_12);
+lean_ctor_set(x_13, 1, x_6);
+return x_13;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_13 = lean_ctor_get(x_6, 1);
-x_14 = lean_ctor_get(x_6, 2);
-x_15 = lean_ctor_get(x_6, 3);
+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; 
+x_14 = lean_ctor_get(x_6, 1);
+x_15 = lean_ctor_get(x_6, 2);
+x_16 = lean_ctor_get(x_6, 3);
+lean_inc(x_16);
 lean_inc(x_15);
 lean_inc(x_14);
-lean_inc(x_13);
 lean_dec(x_6);
-x_16 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_16, 0, x_5);
-lean_ctor_set(x_16, 1, x_15);
-x_17 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_17, 0, x_4);
-lean_ctor_set(x_17, 1, x_13);
-lean_ctor_set(x_17, 2, x_14);
-lean_ctor_set(x_17, 3, x_16);
-x_18 = lean_box(0);
-x_19 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_19, 0, x_18);
-lean_ctor_set(x_19, 1, x_17);
-return x_19;
+x_17 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_17, 0, x_5);
+lean_ctor_set(x_17, 1, x_16);
+x_18 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_18, 0, x_7);
+lean_ctor_set(x_18, 1, x_14);
+lean_ctor_set(x_18, 2, x_15);
+lean_ctor_set(x_18, 3, x_17);
+x_19 = lean_box(0);
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_19);
+lean_ctor_set(x_20, 1, x_18);
+return x_20;
 }
 }
 else
 {
-uint8_t x_20; 
-x_20 = !lean_is_exclusive(x_4);
-if (x_20 == 0)
+uint8_t x_21; 
+x_21 = !lean_is_exclusive(x_4);
+if (x_21 == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_21 = lean_ctor_get(x_4, 0);
-x_22 = lean_ctor_get(x_4, 1);
-x_23 = l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1;
-lean_inc(x_21);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_22 = lean_ctor_get(x_4, 0);
+x_23 = lean_ctor_get(x_4, 1);
+x_24 = l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1;
+lean_inc(x_22);
 lean_inc(x_2);
 lean_inc(x_1);
-x_24 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1___rarg(x_1, x_2, x_21, x_23, x_6);
-x_25 = !lean_is_exclusive(x_24);
-if (x_25 == 0)
+x_25 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1___rarg(x_1, x_2, x_22, x_24, x_6);
+x_26 = !lean_is_exclusive(x_25);
+if (x_26 == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; 
-x_26 = lean_ctor_get(x_24, 1);
-x_27 = lean_ctor_get(x_24, 0);
-lean_dec(x_27);
-lean_inc(x_21);
+lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_27 = lean_ctor_get(x_25, 1);
+x_28 = lean_ctor_get(x_25, 0);
+lean_dec(x_28);
+lean_inc(x_22);
 lean_ctor_set(x_4, 1, x_5);
 lean_inc(x_1);
 lean_inc(x_3);
-x_28 = lean_apply_2(x_1, x_3, x_21);
-x_29 = lean_unbox(x_28);
-lean_dec(x_28);
-if (x_29 == 0)
+x_29 = lean_apply_2(x_1, x_3, x_22);
+x_30 = lean_unbox(x_29);
+lean_dec(x_29);
+if (x_30 == 0)
 {
-lean_free_object(x_24);
+lean_free_object(x_25);
 {
-lean_object* _tmp_3 = x_22;
+lean_object* _tmp_3 = x_23;
 lean_object* _tmp_4 = x_4;
-lean_object* _tmp_5 = x_26;
+lean_object* _tmp_5 = x_27;
 x_4 = _tmp_3;
 x_5 = _tmp_4;
 x_6 = _tmp_5;
@@ -850,70 +1081,70 @@ goto _start;
 }
 else
 {
-uint8_t x_31; 
+uint8_t x_32; 
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_31 = !lean_is_exclusive(x_26);
-if (x_31 == 0)
+x_32 = !lean_is_exclusive(x_27);
+if (x_32 == 0)
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_32 = lean_ctor_get(x_26, 3);
-x_33 = lean_ctor_get(x_26, 0);
-lean_dec(x_33);
-x_34 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_34, 0, x_4);
-lean_ctor_set(x_34, 1, x_32);
-lean_ctor_set(x_26, 3, x_34);
-lean_ctor_set(x_26, 0, x_22);
-x_35 = lean_box(0);
-lean_ctor_set(x_24, 0, x_35);
-return x_24;
+lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_33 = lean_ctor_get(x_27, 3);
+x_34 = lean_ctor_get(x_27, 0);
+lean_dec(x_34);
+x_35 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_35, 0, x_4);
+lean_ctor_set(x_35, 1, x_33);
+lean_ctor_set(x_27, 3, x_35);
+lean_ctor_set(x_27, 0, x_23);
+x_36 = lean_box(0);
+lean_ctor_set(x_25, 0, x_36);
+return x_25;
 }
 else
 {
-lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_36 = lean_ctor_get(x_26, 1);
-x_37 = lean_ctor_get(x_26, 2);
-x_38 = lean_ctor_get(x_26, 3);
+lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; 
+x_37 = lean_ctor_get(x_27, 1);
+x_38 = lean_ctor_get(x_27, 2);
+x_39 = lean_ctor_get(x_27, 3);
+lean_inc(x_39);
 lean_inc(x_38);
 lean_inc(x_37);
-lean_inc(x_36);
-lean_dec(x_26);
-x_39 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_39, 0, x_4);
-lean_ctor_set(x_39, 1, x_38);
-x_40 = lean_alloc_ctor(0, 4, 0);
-lean_ctor_set(x_40, 0, x_22);
-lean_ctor_set(x_40, 1, x_36);
-lean_ctor_set(x_40, 2, x_37);
-lean_ctor_set(x_40, 3, x_39);
-x_41 = lean_box(0);
-lean_ctor_set(x_24, 1, x_40);
-lean_ctor_set(x_24, 0, x_41);
-return x_24;
+lean_dec(x_27);
+x_40 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_40, 0, x_4);
+lean_ctor_set(x_40, 1, x_39);
+x_41 = lean_alloc_ctor(0, 4, 0);
+lean_ctor_set(x_41, 0, x_23);
+lean_ctor_set(x_41, 1, x_37);
+lean_ctor_set(x_41, 2, x_38);
+lean_ctor_set(x_41, 3, x_40);
+x_42 = lean_box(0);
+lean_ctor_set(x_25, 1, x_41);
+lean_ctor_set(x_25, 0, x_42);
+return x_25;
 }
 }
 }
 else
 {
-lean_object* x_42; lean_object* x_43; uint8_t x_44; 
-x_42 = lean_ctor_get(x_24, 1);
-lean_inc(x_42);
-lean_dec(x_24);
-lean_inc(x_21);
+lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_43 = lean_ctor_get(x_25, 1);
+lean_inc(x_43);
+lean_dec(x_25);
+lean_inc(x_22);
 lean_ctor_set(x_4, 1, x_5);
 lean_inc(x_1);
 lean_inc(x_3);
-x_43 = lean_apply_2(x_1, x_3, x_21);
-x_44 = lean_unbox(x_43);
-lean_dec(x_43);
-if (x_44 == 0)
+x_44 = lean_apply_2(x_1, x_3, x_22);
+x_45 = lean_unbox(x_44);
+lean_dec(x_44);
+if (x_45 == 0)
 {
 {
-lean_object* _tmp_3 = x_22;
+lean_object* _tmp_3 = x_23;
 lean_object* _tmp_4 = x_4;
-lean_object* _tmp_5 = x_42;
+lean_object* _tmp_5 = x_43;
 x_4 = _tmp_3;
 x_5 = _tmp_4;
 x_6 = _tmp_5;
@@ -922,185 +1153,169 @@ goto _start;
 }
 else
 {
-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_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_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-x_46 = lean_ctor_get(x_42, 1);
-lean_inc(x_46);
-x_47 = lean_ctor_get(x_42, 2);
+x_47 = lean_ctor_get(x_43, 1);
 lean_inc(x_47);
-x_48 = lean_ctor_get(x_42, 3);
+x_48 = lean_ctor_get(x_43, 2);
 lean_inc(x_48);
-if (lean_is_exclusive(x_42)) {
- lean_ctor_release(x_42, 0);
- lean_ctor_release(x_42, 1);
- lean_ctor_release(x_42, 2);
- lean_ctor_release(x_42, 3);
- x_49 = x_42;
+x_49 = lean_ctor_get(x_43, 3);
+lean_inc(x_49);
+if (lean_is_exclusive(x_43)) {
+ lean_ctor_release(x_43, 0);
+ lean_ctor_release(x_43, 1);
+ lean_ctor_release(x_43, 2);
+ lean_ctor_release(x_43, 3);
+ x_50 = x_43;
 } else {
- lean_dec_ref(x_42);
- x_49 = lean_box(0);
+ lean_dec_ref(x_43);
+ x_50 = lean_box(0);
 }
-x_50 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_50, 0, x_4);
-lean_ctor_set(x_50, 1, x_48);
-if (lean_is_scalar(x_49)) {
- x_51 = lean_alloc_ctor(0, 4, 0);
+x_51 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_51, 0, x_4);
+lean_ctor_set(x_51, 1, x_49);
+if (lean_is_scalar(x_50)) {
+ x_52 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_51 = x_49;
+ x_52 = x_50;
 }
-lean_ctor_set(x_51, 0, x_22);
-lean_ctor_set(x_51, 1, x_46);
-lean_ctor_set(x_51, 2, x_47);
-lean_ctor_set(x_51, 3, x_50);
-x_52 = lean_box(0);
-x_53 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_51);
-return x_53;
+lean_ctor_set(x_52, 0, x_23);
+lean_ctor_set(x_52, 1, x_47);
+lean_ctor_set(x_52, 2, x_48);
+lean_ctor_set(x_52, 3, x_51);
+x_53 = lean_box(0);
+x_54 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_54, 0, x_53);
+lean_ctor_set(x_54, 1, x_52);
+return x_54;
 }
 }
 }
 else
 {
-lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_54 = lean_ctor_get(x_4, 0);
-x_55 = lean_ctor_get(x_4, 1);
+lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; 
+x_55 = lean_ctor_get(x_4, 0);
+x_56 = lean_ctor_get(x_4, 1);
+lean_inc(x_56);
 lean_inc(x_55);
-lean_inc(x_54);
 lean_dec(x_4);
-x_56 = l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1;
-lean_inc(x_54);
+x_57 = l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1;
+lean_inc(x_55);
 lean_inc(x_2);
 lean_inc(x_1);
-x_57 = l___private_Lean_Util_SCC_3__modifyDataOf___at___private_Lean_Util_SCC_4__resetOnStack___spec__1___rarg(x_1, x_2, x_54, x_56, x_6);
-x_58 = lean_ctor_get(x_57, 1);
-lean_inc(x_58);
-if (lean_is_exclusive(x_57)) {
- lean_ctor_release(x_57, 0);
- lean_ctor_release(x_57, 1);
- x_59 = x_57;
-} else {
- lean_dec_ref(x_57);
- x_59 = lean_box(0);
-}
-lean_inc(x_54);
-x_60 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_60, 0, x_54);
-lean_ctor_set(x_60, 1, x_5);
-lean_inc(x_1);
-lean_inc(x_3);
-x_61 = lean_apply_2(x_1, x_3, x_54);
-x_62 = lean_unbox(x_61);
-lean_dec(x_61);
-if (x_62 == 0)
-{
-lean_dec(x_59);
-x_4 = x_55;
-x_5 = x_60;
-x_6 = x_58;
-goto _start;
-}
-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_dec(x_3);
-lean_dec(x_2);
-lean_dec(x_1);
-x_64 = lean_ctor_get(x_58, 1);
-lean_inc(x_64);
-x_65 = lean_ctor_get(x_58, 2);
-lean_inc(x_65);
-x_66 = lean_ctor_get(x_58, 3);
-lean_inc(x_66);
+x_58 = l___private_Lean_Util_SCC_0__Lean_SCC_modifyDataOf___at___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___spec__1___rarg(x_1, x_2, x_55, x_57, x_6);
+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);
- lean_ctor_release(x_58, 2);
- lean_ctor_release(x_58, 3);
- x_67 = x_58;
+ x_60 = x_58;
 } else {
  lean_dec_ref(x_58);
- x_67 = lean_box(0);
+ x_60 = lean_box(0);
 }
-x_68 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_68, 0, x_60);
-lean_ctor_set(x_68, 1, x_66);
-if (lean_is_scalar(x_67)) {
- x_69 = lean_alloc_ctor(0, 4, 0);
+lean_inc(x_55);
+x_61 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_61, 0, x_55);
+lean_ctor_set(x_61, 1, x_5);
+lean_inc(x_1);
+lean_inc(x_3);
+x_62 = lean_apply_2(x_1, x_3, x_55);
+x_63 = lean_unbox(x_62);
+lean_dec(x_62);
+if (x_63 == 0)
+{
+lean_dec(x_60);
+x_4 = x_56;
+x_5 = x_61;
+x_6 = x_59;
+goto _start;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+lean_dec(x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_65 = lean_ctor_get(x_59, 1);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_59, 2);
+lean_inc(x_66);
+x_67 = lean_ctor_get(x_59, 3);
+lean_inc(x_67);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ lean_ctor_release(x_59, 2);
+ lean_ctor_release(x_59, 3);
+ x_68 = x_59;
 } else {
- x_69 = x_67;
+ lean_dec_ref(x_59);
+ x_68 = lean_box(0);
 }
-lean_ctor_set(x_69, 0, x_55);
-lean_ctor_set(x_69, 1, x_64);
-lean_ctor_set(x_69, 2, x_65);
-lean_ctor_set(x_69, 3, x_68);
-x_70 = lean_box(0);
-if (lean_is_scalar(x_59)) {
- x_71 = lean_alloc_ctor(0, 2, 0);
+x_69 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_69, 0, x_61);
+lean_ctor_set(x_69, 1, x_67);
+if (lean_is_scalar(x_68)) {
+ x_70 = lean_alloc_ctor(0, 4, 0);
 } else {
- x_71 = x_59;
+ x_70 = x_68;
 }
-lean_ctor_set(x_71, 0, x_70);
-lean_ctor_set(x_71, 1, x_69);
-return x_71;
+lean_ctor_set(x_70, 0, x_56);
+lean_ctor_set(x_70, 1, x_65);
+lean_ctor_set(x_70, 2, x_66);
+lean_ctor_set(x_70, 3, x_69);
+x_71 = lean_box(0);
+if (lean_is_scalar(x_60)) {
+ x_72 = lean_alloc_ctor(0, 2, 0);
+} else {
+ x_72 = x_60;
+}
+lean_ctor_set(x_72, 0, x_71);
+lean_ctor_set(x_72, 1, x_70);
+return x_72;
 }
 }
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___main(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_6__addSCCAux___main___rarg), 6, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___rarg), 6, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
-_start:
-{
-lean_object* x_7; 
-x_7 = l___private_Lean_Util_SCC_6__addSCCAux___main___rarg(x_1, x_2, x_3, x_4, x_5, x_6);
-return x_7;
-}
-}
-lean_object* l___private_Lean_Util_SCC_6__addSCCAux(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_6__addSCCAux___rarg), 6, 0);
-return x_2;
-}
-}
-lean_object* l___private_Lean_Util_SCC_7__addSCC___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_ctor_get(x_4, 0);
 lean_inc(x_5);
 x_6 = lean_box(0);
-x_7 = l___private_Lean_Util_SCC_6__addSCCAux___main___rarg(x_1, x_2, x_3, x_5, x_6, x_4);
+x_7 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCCAux___rarg(x_1, x_2, x_3, x_5, x_6, x_4);
 return x_7;
 }
 }
-lean_object* l___private_Lean_Util_SCC_7__addSCC(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_addSCC(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_7__addSCC___rarg), 4, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___rarg), 4, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; lean_object* x_9; 
 lean_inc(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_7 = l___private_Lean_Util_SCC_1__getDataOf___rarg(x_1, x_2, x_5, x_6);
+x_7 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg(x_1, x_2, x_5, x_6);
 x_8 = lean_ctor_get(x_7, 0);
 lean_inc(x_8);
 x_9 = lean_ctor_get(x_8, 0);
@@ -1115,13 +1330,13 @@ lean_dec(x_7);
 lean_inc(x_5);
 lean_inc(x_2);
 lean_inc(x_1);
-x_11 = l___private_Lean_Util_SCC_8__sccAux___main___rarg(x_1, x_2, x_3, x_5, x_10);
+x_11 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg(x_1, x_2, x_3, x_5, x_10);
 x_12 = lean_ctor_get(x_11, 1);
 lean_inc(x_12);
 lean_dec(x_11);
 lean_inc(x_2);
 lean_inc(x_1);
-x_13 = l___private_Lean_Util_SCC_1__getDataOf___rarg(x_1, x_2, x_5, x_12);
+x_13 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg(x_1, x_2, x_5, x_12);
 x_14 = lean_ctor_get(x_13, 0);
 lean_inc(x_14);
 x_15 = lean_ctor_get(x_13, 1);
@@ -1130,7 +1345,7 @@ lean_dec(x_13);
 x_16 = lean_ctor_get(x_14, 1);
 lean_inc(x_16);
 lean_dec(x_14);
-x_17 = l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg(x_1, x_2, x_4, x_16, x_15);
+x_17 = l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg(x_1, x_2, x_4, x_16, x_15);
 return x_17;
 }
 else
@@ -1176,13 +1391,13 @@ lean_object* x_25; lean_object* x_26;
 x_25 = lean_ctor_get(x_7, 1);
 lean_inc(x_25);
 lean_dec(x_7);
-x_26 = l___private_Lean_Util_SCC_5__updateLowLinkOf___rarg(x_1, x_2, x_4, x_9, x_25);
+x_26 = l___private_Lean_Util_SCC_0__Lean_SCC_updateLowLinkOf___rarg(x_1, x_2, x_4, x_9, x_25);
 return x_26;
 }
 }
 }
 }
-static lean_object* _init_l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1() {
+static lean_object* _init_l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; 
@@ -1191,14 +1406,14 @@ x_2 = l_StateT_Monad___rarg(x_1);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
 _start:
 {
 lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
 lean_inc(x_4);
 lean_inc(x_2);
 lean_inc(x_1);
-x_6 = l___private_Lean_Util_SCC_2__push___rarg(x_1, x_2, x_4, x_5);
+x_6 = l___private_Lean_Util_SCC_0__Lean_SCC_push___rarg(x_1, x_2, x_4, x_5);
 x_7 = lean_ctor_get(x_6, 1);
 lean_inc(x_7);
 lean_dec(x_6);
@@ -1206,14 +1421,14 @@ lean_inc(x_4);
 lean_inc(x_3);
 lean_inc(x_2);
 lean_inc(x_1);
-x_8 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_8__sccAux___main___rarg___lambda__1), 6, 4);
+x_8 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___lambda__1), 6, 4);
 lean_closure_set(x_8, 0, x_1);
 lean_closure_set(x_8, 1, x_2);
 lean_closure_set(x_8, 2, x_3);
 lean_closure_set(x_8, 3, x_4);
 lean_inc(x_4);
 x_9 = lean_apply_1(x_3, x_4);
-x_10 = l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1;
+x_10 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1;
 x_11 = l_List_forM___main___rarg(x_10, lean_box(0), x_8, x_9);
 x_12 = lean_apply_1(x_11, x_7);
 x_13 = lean_ctor_get(x_12, 1);
@@ -1222,7 +1437,7 @@ lean_dec(x_12);
 lean_inc(x_4);
 lean_inc(x_2);
 lean_inc(x_1);
-x_14 = l___private_Lean_Util_SCC_1__getDataOf___rarg(x_1, x_2, x_4, x_13);
+x_14 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg(x_1, x_2, x_4, x_13);
 x_15 = lean_ctor_get(x_14, 0);
 lean_inc(x_15);
 x_16 = lean_ctor_get(x_15, 1);
@@ -1239,7 +1454,7 @@ lean_object* x_18; lean_object* x_19;
 x_18 = lean_ctor_get(x_14, 1);
 lean_inc(x_18);
 lean_dec(x_14);
-x_19 = l___private_Lean_Util_SCC_7__addSCC___rarg(x_1, x_2, x_4, x_18);
+x_19 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___rarg(x_1, x_2, x_4, x_18);
 return x_19;
 }
 else
@@ -1342,7 +1557,7 @@ else
 {
 lean_object* x_40; 
 lean_free_object(x_14);
-x_40 = l___private_Lean_Util_SCC_7__addSCC___rarg(x_1, x_2, x_4, x_34);
+x_40 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___rarg(x_1, x_2, x_4, x_34);
 return x_40;
 }
 }
@@ -1376,7 +1591,7 @@ return x_46;
 else
 {
 lean_object* x_47; 
-x_47 = l___private_Lean_Util_SCC_7__addSCC___rarg(x_1, x_2, x_4, x_41);
+x_47 = l___private_Lean_Util_SCC_0__Lean_SCC_addSCC___rarg(x_1, x_2, x_4, x_41);
 return x_47;
 }
 }
@@ -1384,28 +1599,43 @@ return x_47;
 }
 }
 }
-lean_object* l___private_Lean_Util_SCC_8__sccAux___main(lean_object* x_1) {
+lean_object* l___private_Lean_Util_SCC_0__Lean_SCC_sccAux(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_8__sccAux___main___rarg), 5, 0);
+x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg), 5, 0);
 return x_2;
 }
 }
-lean_object* l___private_Lean_Util_SCC_8__sccAux___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+lean_object* l_Lean_SCC_scc_match__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
-lean_object* x_6; 
-x_6 = l___private_Lean_Util_SCC_8__sccAux___main___rarg(x_1, x_2, x_3, x_4, x_5);
-return x_6;
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_apply_2(x_2, x_3, x_4);
+return x_5;
 }
 }
-lean_object* l___private_Lean_Util_SCC_8__sccAux(lean_object* x_1) {
+lean_object* l_Lean_SCC_scc_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l___private_Lean_Util_SCC_8__sccAux___rarg), 5, 0);
-return x_2;
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Lean_SCC_scc_match__1___rarg), 2, 0);
+return x_5;
+}
+}
+lean_object* l_Lean_SCC_scc_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Lean_SCC_scc_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+return x_5;
 }
 }
 lean_object* l_Lean_SCC_scc___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
@@ -1415,7 +1645,7 @@ lean_object* x_6; lean_object* x_7; lean_object* x_8;
 lean_inc(x_4);
 lean_inc(x_2);
 lean_inc(x_1);
-x_6 = l___private_Lean_Util_SCC_1__getDataOf___rarg(x_1, x_2, x_4, x_5);
+x_6 = l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg(x_1, x_2, x_4, x_5);
 x_7 = lean_ctor_get(x_6, 0);
 lean_inc(x_7);
 x_8 = lean_ctor_get(x_7, 0);
@@ -1427,7 +1657,7 @@ lean_object* x_9; lean_object* x_10;
 x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
 lean_dec(x_6);
-x_10 = l___private_Lean_Util_SCC_8__sccAux___main___rarg(x_1, x_2, x_3, x_4, x_9);
+x_10 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg(x_1, x_2, x_3, x_4, x_9);
 return x_10;
 }
 else
@@ -1479,7 +1709,7 @@ lean_ctor_set(x_9, 0, x_6);
 lean_ctor_set(x_9, 1, x_7);
 lean_ctor_set(x_9, 2, x_8);
 lean_ctor_set(x_9, 3, x_6);
-x_10 = l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1;
+x_10 = l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1;
 x_11 = l_List_forM___main___rarg(x_10, lean_box(0), x_5, x_3);
 x_12 = lean_apply_1(x_11, x_9);
 x_13 = lean_ctor_get(x_12, 1);
@@ -1513,12 +1743,19 @@ lean_dec_ref(res);
 res = initialize_Std_Data_HashMap(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1 = _init_l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1();
-lean_mark_persistent(l___private_Lean_Util_SCC_1__getDataOf___rarg___closed__1);
-l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1 = _init_l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1();
-lean_mark_persistent(l___private_Lean_Util_SCC_4__resetOnStack___rarg___closed__1);
-l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1 = _init_l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1();
-lean_mark_persistent(l___private_Lean_Util_SCC_8__sccAux___main___rarg___closed__1);
+l_Lean_SCC_Data_index_x3f___default = _init_l_Lean_SCC_Data_index_x3f___default();
+lean_mark_persistent(l_Lean_SCC_Data_index_x3f___default);
+l_Lean_SCC_Data_lowlink_x3f___default = _init_l_Lean_SCC_Data_lowlink_x3f___default();
+lean_mark_persistent(l_Lean_SCC_Data_lowlink_x3f___default);
+l_Lean_SCC_Data_onStack___default = _init_l_Lean_SCC_Data_onStack___default();
+l_Lean_SCC_State_nextIndex___default = _init_l_Lean_SCC_State_nextIndex___default();
+lean_mark_persistent(l_Lean_SCC_State_nextIndex___default);
+l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1 = _init_l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1();
+lean_mark_persistent(l___private_Lean_Util_SCC_0__Lean_SCC_getDataOf___rarg___closed__1);
+l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1 = _init_l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1();
+lean_mark_persistent(l___private_Lean_Util_SCC_0__Lean_SCC_resetOnStack___rarg___closed__1);
+l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1 = _init_l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1();
+lean_mark_persistent(l___private_Lean_Util_SCC_0__Lean_SCC_sccAux___rarg___closed__1);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Lean/Util/Sorry.c b/stage0/stdlib/Lean/Util/Sorry.c
index 1c8d5c2079..9bf361bb5c 100644
--- a/stage0/stdlib/Lean/Util/Sorry.c
+++ b/stage0/stdlib/Lean/Util/Sorry.c
@@ -13,44 +13,50 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-uint8_t l_Lean_MessageData_hasSyntheticSorry___main(lean_object*);
+lean_object* l_Lean_Expr_hasSyntheticSorry_match__1(lean_object*);
 uint8_t l_Lean_Expr_isSyntheticSorry(lean_object*);
-lean_object* l_Lean_Expr_hasSorry___main___closed__1;
-uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_hasSorry___main___boxed(lean_object*);
 uint8_t lean_name_eq(lean_object*, lean_object*);
-lean_object* l_Lean_MessageData_hasSyntheticSorry___main___boxed(lean_object*);
-uint8_t l_Lean_Expr_hasSorry___main(lean_object*);
+lean_object* l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_MessageData_hasSorry_match__1(lean_object*);
 lean_object* l_Lean_MessageData_hasSyntheticSorry___boxed(lean_object*);
 lean_object* lean_array_get_size(lean_object*);
+lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_Expr_hasSyntheticSorry(lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
-lean_object* l_Lean_MessageData_hasSorry___main___boxed(lean_object*);
 lean_object* lean_array_fget(lean_object*, lean_object*);
-lean_object* l_Lean_Expr_isSyntheticSorry___closed__1;
+lean_object* l_Lean_MessageData_hasSyntheticSorry_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_hasSyntheticSorry___boxed(lean_object*);
 lean_object* l_Lean_Expr_isSyntheticSorry___boxed(lean_object*);
-uint8_t l_Lean_MessageData_hasSorry___main(lean_object*);
 uint8_t l_Lean_Exception_hasSyntheticSorry(lean_object*);
-uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___main___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
-uint8_t l_Lean_Expr_hasSyntheticSorry___main(lean_object*);
+lean_object* l_Lean_Expr_isSyntheticSorry_match__1(lean_object*);
+lean_object* l_Lean_Expr_isSyntheticSorry_match__1___rarg(lean_object*, lean_object*, lean_object*);
+uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___spec__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* lean_name_mk_string(lean_object*, lean_object*);
-lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Lean_Expr_isSorry___closed__1;
+lean_object* l_Lean_Exception_hasSyntheticSorry_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_MessageData_hasSyntheticSorry(lean_object*);
-lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___main___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_MessageData_hasSorry___boxed(lean_object*);
+lean_object* l_Lean_MessageData_hasSyntheticSorry_match__1(lean_object*);
+lean_object* l_Lean_MessageData_hasSorry_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Lean_Expr_isSorry___boxed(lean_object*);
+lean_object* l_Lean_Expr_isSorry_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_hasSorry_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Bool_HasRepr___closed__2;
+lean_object* l_Lean_Expr_isSorry_match__1(lean_object*);
+lean_object* l_Lean_Expr_isSorry_match__1___rarg___closed__1;
 lean_object* l_Lean_Exception_hasSyntheticSorry___boxed(lean_object*);
+lean_object* l_Lean_Expr_hasSorry___closed__1;
 uint8_t l_Lean_Expr_hasSorry(lean_object*);
 lean_object* l_Lean_Expr_hasSorry___boxed(lean_object*);
-lean_object* l_Lean_Expr_hasSyntheticSorry___main___boxed(lean_object*);
+lean_object* l_Lean_Expr_hasSyntheticSorry_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Lean_Expr_hasSorry_match__1(lean_object*);
+lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Lean_MessageData_hasSorry(lean_object*);
+lean_object* l_Lean_Exception_hasSyntheticSorry_match__1(lean_object*);
 uint8_t l_Lean_Expr_isSorry(lean_object*);
 uint8_t lean_string_dec_eq(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-static lean_object* _init_l_Lean_Expr_isSorry___closed__1() {
+static lean_object* _init_l_Lean_Expr_isSorry_match__1___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -58,6 +64,132 @@ x_1 = lean_mk_string("sorryAx");
 return x_1;
 }
 }
+lean_object* l_Lean_Expr_isSorry_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 5)
+{
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+if (lean_obj_tag(x_4) == 5)
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 4)
+{
+lean_object* x_6; 
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 1)
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; uint64_t x_9; lean_object* x_10; uint64_t x_11; lean_object* x_12; uint64_t x_13; lean_object* x_14; size_t x_15; lean_object* x_16; uint8_t x_17; 
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+x_10 = lean_ctor_get(x_4, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get_uint64(x_4, sizeof(void*)*2);
+lean_dec(x_4);
+x_12 = lean_ctor_get(x_5, 1);
+lean_inc(x_12);
+x_13 = lean_ctor_get_uint64(x_5, sizeof(void*)*2);
+lean_dec(x_5);
+x_14 = lean_ctor_get(x_6, 1);
+lean_inc(x_14);
+x_15 = lean_ctor_get_usize(x_6, 2);
+lean_dec(x_6);
+x_16 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
+x_17 = lean_string_dec_eq(x_14, x_16);
+lean_dec(x_14);
+if (x_17 == 0)
+{
+lean_object* x_18; 
+lean_dec(x_12);
+lean_dec(x_10);
+lean_dec(x_8);
+lean_dec(x_2);
+x_18 = lean_apply_1(x_3, x_1);
+return x_18;
+}
+else
+{
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
+lean_dec(x_3);
+lean_dec(x_1);
+x_19 = lean_box_uint64(x_13);
+x_20 = lean_box_uint64(x_11);
+x_21 = lean_box_uint64(x_9);
+x_22 = lean_box_usize(x_15);
+x_23 = lean_apply_7(x_2, x_12, x_19, x_10, x_20, x_8, x_21, x_22);
+return x_23;
+}
+}
+else
+{
+lean_object* x_24; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_24 = lean_apply_1(x_3, x_1);
+return x_24;
+}
+}
+else
+{
+lean_object* x_25; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_25 = lean_apply_1(x_3, x_1);
+return x_25;
+}
+}
+else
+{
+lean_object* x_26; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_26 = lean_apply_1(x_3, x_1);
+return x_26;
+}
+}
+else
+{
+lean_object* x_27; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_27 = lean_apply_1(x_3, x_1);
+return x_27;
+}
+}
+else
+{
+lean_object* x_28; 
+lean_dec(x_2);
+x_28 = lean_apply_1(x_3, x_1);
+return x_28;
+}
+}
+}
+lean_object* l_Lean_Expr_isSorry_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_isSorry_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Expr_isSorry(lean_object* x_1) {
 _start:
 {
@@ -81,7 +213,7 @@ if (lean_obj_tag(x_5) == 0)
 {
 lean_object* x_6; lean_object* x_7; uint8_t x_8; 
 x_6 = lean_ctor_get(x_4, 1);
-x_7 = l_Lean_Expr_isSorry___closed__1;
+x_7 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
 x_8 = lean_string_dec_eq(x_6, x_7);
 return x_8;
 }
@@ -131,7 +263,7 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Expr_isSyntheticSorry___closed__1() {
+static lean_object* _init_l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -139,6 +271,2516 @@ x_1 = lean_mk_string("Bool");
 return x_1;
 }
 }
+lean_object* l_Lean_Expr_isSyntheticSorry_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 5)
+{
+lean_object* x_4; 
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+if (lean_obj_tag(x_4) == 5)
+{
+lean_object* x_5; 
+x_5 = lean_ctor_get(x_4, 0);
+lean_inc(x_5);
+if (lean_obj_tag(x_5) == 4)
+{
+lean_object* x_6; 
+x_6 = lean_ctor_get(x_5, 0);
+lean_inc(x_6);
+if (lean_obj_tag(x_6) == 1)
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; uint8_t x_9; 
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = !lean_is_exclusive(x_4);
+if (x_9 == 0)
+{
+uint64_t x_10; lean_object* x_11; uint64_t x_12; lean_object* x_13; uint8_t x_14; 
+x_10 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+x_11 = lean_ctor_get(x_4, 1);
+x_12 = lean_ctor_get_uint64(x_4, sizeof(void*)*2);
+x_13 = lean_ctor_get(x_4, 0);
+lean_dec(x_13);
+x_14 = !lean_is_exclusive(x_5);
+if (x_14 == 0)
+{
+lean_object* x_15; uint64_t x_16; lean_object* x_17; uint8_t x_18; 
+x_15 = lean_ctor_get(x_5, 1);
+x_16 = lean_ctor_get_uint64(x_5, sizeof(void*)*2);
+x_17 = lean_ctor_get(x_5, 0);
+lean_dec(x_17);
+x_18 = !lean_is_exclusive(x_6);
+if (x_18 == 0)
+{
+lean_object* x_19; size_t x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; 
+x_19 = lean_ctor_get(x_6, 1);
+x_20 = lean_ctor_get_usize(x_6, 2);
+x_21 = lean_ctor_get(x_6, 0);
+lean_dec(x_21);
+x_22 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
+x_23 = lean_string_dec_eq(x_19, x_22);
+lean_dec(x_19);
+if (x_23 == 0)
+{
+lean_object* x_24; 
+lean_free_object(x_6);
+lean_free_object(x_5);
+lean_dec(x_15);
+lean_free_object(x_4);
+lean_dec(x_11);
+lean_dec(x_8);
+lean_dec(x_2);
+x_24 = lean_apply_1(x_3, x_1);
+return x_24;
+}
+else
+{
+uint8_t x_25; 
+x_25 = !lean_is_exclusive(x_1);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; 
+x_26 = lean_ctor_get(x_1, 1);
+lean_dec(x_26);
+x_27 = lean_ctor_get(x_1, 0);
+lean_dec(x_27);
+if (lean_obj_tag(x_8) == 4)
+{
+lean_object* x_28; 
+x_28 = lean_ctor_get(x_8, 0);
+lean_inc(x_28);
+switch (lean_obj_tag(x_28)) {
+case 0:
+{
+lean_object* x_29; 
+lean_dec(x_2);
+lean_ctor_set(x_6, 1, x_22);
+lean_ctor_set(x_6, 0, x_28);
+x_29 = lean_apply_1(x_3, x_1);
+return x_29;
+}
+case 1:
+{
+lean_object* x_30; 
+x_30 = lean_ctor_get(x_28, 0);
+lean_inc(x_30);
+switch (lean_obj_tag(x_30)) {
+case 0:
+{
+uint8_t x_31; 
+lean_free_object(x_6);
+lean_dec(x_2);
+x_31 = !lean_is_exclusive(x_28);
+if (x_31 == 0)
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+x_32 = lean_ctor_get(x_28, 1);
+lean_dec(x_32);
+x_33 = lean_ctor_get(x_28, 0);
+lean_dec(x_33);
+lean_ctor_set(x_28, 1, x_22);
+lean_ctor_set_usize(x_28, 2, x_20);
+lean_ctor_set(x_5, 0, x_28);
+x_34 = lean_apply_1(x_3, x_1);
+return x_34;
+}
+else
+{
+lean_object* x_35; lean_object* x_36; 
+lean_dec(x_28);
+x_35 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_35, 0, x_30);
+lean_ctor_set(x_35, 1, x_22);
+lean_ctor_set_usize(x_35, 2, x_20);
+lean_ctor_set(x_5, 0, x_35);
+x_36 = lean_apply_1(x_3, x_1);
+return x_36;
+}
+}
+case 1:
+{
+lean_object* x_37; 
+x_37 = lean_ctor_get(x_30, 0);
+lean_inc(x_37);
+switch (lean_obj_tag(x_37)) {
+case 0:
+{
+lean_object* x_38; uint8_t x_39; 
+x_38 = lean_ctor_get(x_8, 1);
+lean_inc(x_38);
+x_39 = !lean_is_exclusive(x_28);
+if (x_39 == 0)
+{
+uint64_t x_40; lean_object* x_41; size_t x_42; lean_object* x_43; uint8_t x_44; 
+x_40 = lean_ctor_get_uint64(x_8, sizeof(void*)*2);
+x_41 = lean_ctor_get(x_28, 1);
+x_42 = lean_ctor_get_usize(x_28, 2);
+x_43 = lean_ctor_get(x_28, 0);
+lean_dec(x_43);
+x_44 = !lean_is_exclusive(x_30);
+if (x_44 == 0)
+{
+lean_object* x_45; size_t x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; 
+x_45 = lean_ctor_get(x_30, 1);
+x_46 = lean_ctor_get_usize(x_30, 2);
+x_47 = lean_ctor_get(x_30, 0);
+lean_dec(x_47);
+x_48 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+x_49 = lean_string_dec_eq(x_45, x_48);
+lean_dec(x_45);
+if (x_49 == 0)
+{
+lean_object* x_50; 
+lean_free_object(x_28);
+lean_dec(x_41);
+lean_dec(x_38);
+lean_free_object(x_6);
+lean_dec(x_2);
+lean_ctor_set(x_30, 1, x_22);
+lean_ctor_set_usize(x_30, 2, x_20);
+lean_ctor_set(x_5, 0, x_30);
+x_50 = lean_apply_1(x_3, x_1);
+return x_50;
+}
+else
+{
+uint8_t x_51; 
+x_51 = !lean_is_exclusive(x_8);
+if (x_51 == 0)
+{
+lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; 
+x_52 = lean_ctor_get(x_8, 1);
+lean_dec(x_52);
+x_53 = lean_ctor_get(x_8, 0);
+lean_dec(x_53);
+x_54 = l_Bool_HasRepr___closed__2;
+x_55 = lean_string_dec_eq(x_41, x_54);
+if (x_55 == 0)
+{
+lean_object* x_56; 
+lean_dec(x_2);
+lean_ctor_set(x_30, 1, x_22);
+lean_ctor_set_usize(x_30, 2, x_20);
+lean_ctor_set(x_8, 1, x_15);
+lean_ctor_set(x_8, 0, x_30);
+lean_ctor_set_uint64(x_8, sizeof(void*)*2, x_16);
+lean_ctor_set_tag(x_5, 5);
+lean_ctor_set(x_5, 1, x_11);
+lean_ctor_set(x_5, 0, x_8);
+lean_ctor_set_uint64(x_5, sizeof(void*)*2, x_12);
+lean_ctor_set(x_28, 1, x_48);
+lean_ctor_set(x_28, 0, x_37);
+lean_ctor_set_usize(x_28, 2, x_46);
+lean_ctor_set(x_6, 1, x_41);
+lean_ctor_set(x_6, 0, x_28);
+lean_ctor_set_usize(x_6, 2, x_42);
+lean_ctor_set_tag(x_4, 4);
+lean_ctor_set(x_4, 1, x_38);
+lean_ctor_set(x_4, 0, x_6);
+lean_ctor_set_uint64(x_4, sizeof(void*)*2, x_40);
+lean_ctor_set(x_1, 1, x_4);
+lean_ctor_set(x_1, 0, x_5);
+x_56 = lean_apply_1(x_3, x_1);
+return x_56;
+}
+else
+{
+lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; 
+lean_free_object(x_8);
+lean_free_object(x_30);
+lean_free_object(x_28);
+lean_dec(x_41);
+lean_free_object(x_1);
+lean_free_object(x_6);
+lean_free_object(x_5);
+lean_free_object(x_4);
+lean_dec(x_3);
+x_57 = lean_box_uint64(x_16);
+x_58 = lean_box_uint64(x_12);
+x_59 = lean_box_uint64(x_40);
+x_60 = lean_box_uint64(x_10);
+x_61 = lean_box_usize(x_20);
+x_62 = lean_box_usize(x_46);
+x_63 = lean_box_usize(x_42);
+x_64 = lean_apply_10(x_2, x_15, x_57, x_11, x_58, x_38, x_59, x_60, x_61, x_62, x_63);
+return x_64;
+}
+}
+else
+{
+lean_object* x_65; uint8_t x_66; 
+lean_dec(x_8);
+x_65 = l_Bool_HasRepr___closed__2;
+x_66 = lean_string_dec_eq(x_41, x_65);
+if (x_66 == 0)
+{
+lean_object* x_67; lean_object* x_68; 
+lean_dec(x_2);
+lean_ctor_set(x_30, 1, x_22);
+lean_ctor_set_usize(x_30, 2, x_20);
+x_67 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_67, 0, x_30);
+lean_ctor_set(x_67, 1, x_15);
+lean_ctor_set_uint64(x_67, sizeof(void*)*2, x_16);
+lean_ctor_set_tag(x_5, 5);
+lean_ctor_set(x_5, 1, x_11);
+lean_ctor_set(x_5, 0, x_67);
+lean_ctor_set_uint64(x_5, sizeof(void*)*2, x_12);
+lean_ctor_set(x_28, 1, x_48);
+lean_ctor_set(x_28, 0, x_37);
+lean_ctor_set_usize(x_28, 2, x_46);
+lean_ctor_set(x_6, 1, x_41);
+lean_ctor_set(x_6, 0, x_28);
+lean_ctor_set_usize(x_6, 2, x_42);
+lean_ctor_set_tag(x_4, 4);
+lean_ctor_set(x_4, 1, x_38);
+lean_ctor_set(x_4, 0, x_6);
+lean_ctor_set_uint64(x_4, sizeof(void*)*2, x_40);
+lean_ctor_set(x_1, 1, x_4);
+lean_ctor_set(x_1, 0, x_5);
+x_68 = lean_apply_1(x_3, x_1);
+return x_68;
+}
+else
+{
+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_free_object(x_30);
+lean_free_object(x_28);
+lean_dec(x_41);
+lean_free_object(x_1);
+lean_free_object(x_6);
+lean_free_object(x_5);
+lean_free_object(x_4);
+lean_dec(x_3);
+x_69 = lean_box_uint64(x_16);
+x_70 = lean_box_uint64(x_12);
+x_71 = lean_box_uint64(x_40);
+x_72 = lean_box_uint64(x_10);
+x_73 = lean_box_usize(x_20);
+x_74 = lean_box_usize(x_46);
+x_75 = lean_box_usize(x_42);
+x_76 = lean_apply_10(x_2, x_15, x_69, x_11, x_70, x_38, x_71, x_72, x_73, x_74, x_75);
+return x_76;
+}
+}
+}
+}
+else
+{
+lean_object* x_77; size_t x_78; lean_object* x_79; uint8_t x_80; 
+x_77 = lean_ctor_get(x_30, 1);
+x_78 = lean_ctor_get_usize(x_30, 2);
+lean_inc(x_77);
+lean_dec(x_30);
+x_79 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+x_80 = lean_string_dec_eq(x_77, x_79);
+lean_dec(x_77);
+if (x_80 == 0)
+{
+lean_object* x_81; lean_object* x_82; 
+lean_free_object(x_28);
+lean_dec(x_41);
+lean_dec(x_38);
+lean_free_object(x_6);
+lean_dec(x_2);
+x_81 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_81, 0, x_37);
+lean_ctor_set(x_81, 1, x_22);
+lean_ctor_set_usize(x_81, 2, x_20);
+lean_ctor_set(x_5, 0, x_81);
+x_82 = lean_apply_1(x_3, x_1);
+return x_82;
+}
+else
+{
+lean_object* x_83; lean_object* x_84; uint8_t x_85; 
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_83 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_83 = lean_box(0);
+}
+x_84 = l_Bool_HasRepr___closed__2;
+x_85 = lean_string_dec_eq(x_41, x_84);
+if (x_85 == 0)
+{
+lean_object* x_86; lean_object* x_87; lean_object* x_88; 
+lean_dec(x_2);
+x_86 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_86, 0, x_37);
+lean_ctor_set(x_86, 1, x_22);
+lean_ctor_set_usize(x_86, 2, x_20);
+if (lean_is_scalar(x_83)) {
+ x_87 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_87 = x_83;
+}
+lean_ctor_set(x_87, 0, x_86);
+lean_ctor_set(x_87, 1, x_15);
+lean_ctor_set_uint64(x_87, sizeof(void*)*2, x_16);
+lean_ctor_set_tag(x_5, 5);
+lean_ctor_set(x_5, 1, x_11);
+lean_ctor_set(x_5, 0, x_87);
+lean_ctor_set_uint64(x_5, sizeof(void*)*2, x_12);
+lean_ctor_set(x_28, 1, x_79);
+lean_ctor_set(x_28, 0, x_37);
+lean_ctor_set_usize(x_28, 2, x_78);
+lean_ctor_set(x_6, 1, x_41);
+lean_ctor_set(x_6, 0, x_28);
+lean_ctor_set_usize(x_6, 2, x_42);
+lean_ctor_set_tag(x_4, 4);
+lean_ctor_set(x_4, 1, x_38);
+lean_ctor_set(x_4, 0, x_6);
+lean_ctor_set_uint64(x_4, sizeof(void*)*2, x_40);
+lean_ctor_set(x_1, 1, x_4);
+lean_ctor_set(x_1, 0, x_5);
+x_88 = lean_apply_1(x_3, x_1);
+return x_88;
+}
+else
+{
+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_dec(x_83);
+lean_free_object(x_28);
+lean_dec(x_41);
+lean_free_object(x_1);
+lean_free_object(x_6);
+lean_free_object(x_5);
+lean_free_object(x_4);
+lean_dec(x_3);
+x_89 = lean_box_uint64(x_16);
+x_90 = lean_box_uint64(x_12);
+x_91 = lean_box_uint64(x_40);
+x_92 = lean_box_uint64(x_10);
+x_93 = lean_box_usize(x_20);
+x_94 = lean_box_usize(x_78);
+x_95 = lean_box_usize(x_42);
+x_96 = lean_apply_10(x_2, x_15, x_89, x_11, x_90, x_38, x_91, x_92, x_93, x_94, x_95);
+return x_96;
+}
+}
+}
+}
+else
+{
+uint64_t x_97; lean_object* x_98; size_t x_99; lean_object* x_100; size_t x_101; lean_object* x_102; lean_object* x_103; uint8_t x_104; 
+x_97 = lean_ctor_get_uint64(x_8, sizeof(void*)*2);
+x_98 = lean_ctor_get(x_28, 1);
+x_99 = lean_ctor_get_usize(x_28, 2);
+lean_inc(x_98);
+lean_dec(x_28);
+x_100 = lean_ctor_get(x_30, 1);
+lean_inc(x_100);
+x_101 = lean_ctor_get_usize(x_30, 2);
+if (lean_is_exclusive(x_30)) {
+ lean_ctor_release(x_30, 0);
+ lean_ctor_release(x_30, 1);
+ x_102 = x_30;
+} else {
+ lean_dec_ref(x_30);
+ x_102 = lean_box(0);
+}
+x_103 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+x_104 = lean_string_dec_eq(x_100, x_103);
+lean_dec(x_100);
+if (x_104 == 0)
+{
+lean_object* x_105; lean_object* x_106; 
+lean_dec(x_98);
+lean_dec(x_38);
+lean_free_object(x_6);
+lean_dec(x_2);
+if (lean_is_scalar(x_102)) {
+ x_105 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_105 = x_102;
+}
+lean_ctor_set(x_105, 0, x_37);
+lean_ctor_set(x_105, 1, x_22);
+lean_ctor_set_usize(x_105, 2, x_20);
+lean_ctor_set(x_5, 0, x_105);
+x_106 = lean_apply_1(x_3, x_1);
+return x_106;
+}
+else
+{
+lean_object* x_107; lean_object* x_108; uint8_t x_109; 
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_107 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_107 = lean_box(0);
+}
+x_108 = l_Bool_HasRepr___closed__2;
+x_109 = lean_string_dec_eq(x_98, x_108);
+if (x_109 == 0)
+{
+lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; 
+lean_dec(x_2);
+if (lean_is_scalar(x_102)) {
+ x_110 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_110 = x_102;
+}
+lean_ctor_set(x_110, 0, x_37);
+lean_ctor_set(x_110, 1, x_22);
+lean_ctor_set_usize(x_110, 2, x_20);
+if (lean_is_scalar(x_107)) {
+ x_111 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_111 = x_107;
+}
+lean_ctor_set(x_111, 0, x_110);
+lean_ctor_set(x_111, 1, x_15);
+lean_ctor_set_uint64(x_111, sizeof(void*)*2, x_16);
+lean_ctor_set_tag(x_5, 5);
+lean_ctor_set(x_5, 1, x_11);
+lean_ctor_set(x_5, 0, x_111);
+lean_ctor_set_uint64(x_5, sizeof(void*)*2, x_12);
+x_112 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_112, 0, x_37);
+lean_ctor_set(x_112, 1, x_103);
+lean_ctor_set_usize(x_112, 2, x_101);
+lean_ctor_set(x_6, 1, x_98);
+lean_ctor_set(x_6, 0, x_112);
+lean_ctor_set_usize(x_6, 2, x_99);
+lean_ctor_set_tag(x_4, 4);
+lean_ctor_set(x_4, 1, x_38);
+lean_ctor_set(x_4, 0, x_6);
+lean_ctor_set_uint64(x_4, sizeof(void*)*2, x_97);
+lean_ctor_set(x_1, 1, x_4);
+lean_ctor_set(x_1, 0, x_5);
+x_113 = lean_apply_1(x_3, x_1);
+return x_113;
+}
+else
+{
+lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
+lean_dec(x_107);
+lean_dec(x_102);
+lean_dec(x_98);
+lean_free_object(x_1);
+lean_free_object(x_6);
+lean_free_object(x_5);
+lean_free_object(x_4);
+lean_dec(x_3);
+x_114 = lean_box_uint64(x_16);
+x_115 = lean_box_uint64(x_12);
+x_116 = lean_box_uint64(x_97);
+x_117 = lean_box_uint64(x_10);
+x_118 = lean_box_usize(x_20);
+x_119 = lean_box_usize(x_101);
+x_120 = lean_box_usize(x_99);
+x_121 = lean_apply_10(x_2, x_15, x_114, x_11, x_115, x_38, x_116, x_117, x_118, x_119, x_120);
+return x_121;
+}
+}
+}
+}
+case 1:
+{
+uint8_t x_122; 
+lean_dec(x_30);
+lean_dec(x_28);
+lean_free_object(x_6);
+lean_dec(x_2);
+x_122 = !lean_is_exclusive(x_37);
+if (x_122 == 0)
+{
+lean_object* x_123; lean_object* x_124; lean_object* x_125; 
+x_123 = lean_ctor_get(x_37, 1);
+lean_dec(x_123);
+x_124 = lean_ctor_get(x_37, 0);
+lean_dec(x_124);
+lean_ctor_set(x_37, 1, x_22);
+lean_ctor_set(x_37, 0, x_7);
+lean_ctor_set_usize(x_37, 2, x_20);
+lean_ctor_set(x_5, 0, x_37);
+x_125 = lean_apply_1(x_3, x_1);
+return x_125;
+}
+else
+{
+lean_object* x_126; lean_object* x_127; 
+lean_dec(x_37);
+x_126 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_126, 0, x_7);
+lean_ctor_set(x_126, 1, x_22);
+lean_ctor_set_usize(x_126, 2, x_20);
+lean_ctor_set(x_5, 0, x_126);
+x_127 = lean_apply_1(x_3, x_1);
+return x_127;
+}
+}
+default: 
+{
+uint8_t x_128; 
+lean_dec(x_30);
+lean_dec(x_28);
+lean_free_object(x_6);
+lean_dec(x_2);
+x_128 = !lean_is_exclusive(x_37);
+if (x_128 == 0)
+{
+lean_object* x_129; lean_object* x_130; lean_object* x_131; 
+x_129 = lean_ctor_get(x_37, 1);
+lean_dec(x_129);
+x_130 = lean_ctor_get(x_37, 0);
+lean_dec(x_130);
+lean_ctor_set_tag(x_37, 1);
+lean_ctor_set(x_37, 1, x_22);
+lean_ctor_set(x_37, 0, x_7);
+lean_ctor_set_usize(x_37, 2, x_20);
+lean_ctor_set(x_5, 0, x_37);
+x_131 = lean_apply_1(x_3, x_1);
+return x_131;
+}
+else
+{
+lean_object* x_132; lean_object* x_133; 
+lean_dec(x_37);
+x_132 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_132, 0, x_7);
+lean_ctor_set(x_132, 1, x_22);
+lean_ctor_set_usize(x_132, 2, x_20);
+lean_ctor_set(x_5, 0, x_132);
+x_133 = lean_apply_1(x_3, x_1);
+return x_133;
+}
+}
+}
+}
+default: 
+{
+uint8_t x_134; 
+lean_dec(x_28);
+lean_free_object(x_6);
+lean_dec(x_2);
+x_134 = !lean_is_exclusive(x_30);
+if (x_134 == 0)
+{
+lean_object* x_135; lean_object* x_136; lean_object* x_137; 
+x_135 = lean_ctor_get(x_30, 1);
+lean_dec(x_135);
+x_136 = lean_ctor_get(x_30, 0);
+lean_dec(x_136);
+lean_ctor_set_tag(x_30, 1);
+lean_ctor_set(x_30, 1, x_22);
+lean_ctor_set(x_30, 0, x_7);
+lean_ctor_set_usize(x_30, 2, x_20);
+lean_ctor_set(x_5, 0, x_30);
+x_137 = lean_apply_1(x_3, x_1);
+return x_137;
+}
+else
+{
+lean_object* x_138; lean_object* x_139; 
+lean_dec(x_30);
+x_138 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_138, 0, x_7);
+lean_ctor_set(x_138, 1, x_22);
+lean_ctor_set_usize(x_138, 2, x_20);
+lean_ctor_set(x_5, 0, x_138);
+x_139 = lean_apply_1(x_3, x_1);
+return x_139;
+}
+}
+}
+}
+default: 
+{
+uint8_t x_140; 
+lean_free_object(x_6);
+lean_dec(x_2);
+x_140 = !lean_is_exclusive(x_28);
+if (x_140 == 0)
+{
+lean_object* x_141; lean_object* x_142; lean_object* x_143; 
+x_141 = lean_ctor_get(x_28, 1);
+lean_dec(x_141);
+x_142 = lean_ctor_get(x_28, 0);
+lean_dec(x_142);
+lean_ctor_set_tag(x_28, 1);
+lean_ctor_set(x_28, 1, x_22);
+lean_ctor_set(x_28, 0, x_7);
+lean_ctor_set_usize(x_28, 2, x_20);
+lean_ctor_set(x_5, 0, x_28);
+x_143 = lean_apply_1(x_3, x_1);
+return x_143;
+}
+else
+{
+lean_object* x_144; lean_object* x_145; 
+lean_dec(x_28);
+x_144 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_144, 0, x_7);
+lean_ctor_set(x_144, 1, x_22);
+lean_ctor_set_usize(x_144, 2, x_20);
+lean_ctor_set(x_5, 0, x_144);
+x_145 = lean_apply_1(x_3, x_1);
+return x_145;
+}
+}
+}
+}
+else
+{
+lean_object* x_146; 
+lean_dec(x_2);
+lean_ctor_set(x_6, 1, x_22);
+x_146 = lean_apply_1(x_3, x_1);
+return x_146;
+}
+}
+else
+{
+lean_dec(x_1);
+if (lean_obj_tag(x_8) == 4)
+{
+lean_object* x_147; 
+x_147 = lean_ctor_get(x_8, 0);
+lean_inc(x_147);
+switch (lean_obj_tag(x_147)) {
+case 0:
+{
+lean_object* x_148; lean_object* x_149; 
+lean_dec(x_2);
+lean_ctor_set(x_6, 1, x_22);
+lean_ctor_set(x_6, 0, x_147);
+x_148 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_148, 0, x_4);
+lean_ctor_set(x_148, 1, x_8);
+lean_ctor_set_uint64(x_148, sizeof(void*)*2, x_10);
+x_149 = lean_apply_1(x_3, x_148);
+return x_149;
+}
+case 1:
+{
+lean_object* x_150; 
+x_150 = lean_ctor_get(x_147, 0);
+lean_inc(x_150);
+switch (lean_obj_tag(x_150)) {
+case 0:
+{
+lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; 
+lean_free_object(x_6);
+lean_dec(x_2);
+if (lean_is_exclusive(x_147)) {
+ lean_ctor_release(x_147, 0);
+ lean_ctor_release(x_147, 1);
+ x_151 = x_147;
+} else {
+ lean_dec_ref(x_147);
+ x_151 = lean_box(0);
+}
+if (lean_is_scalar(x_151)) {
+ x_152 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_152 = x_151;
+}
+lean_ctor_set(x_152, 0, x_150);
+lean_ctor_set(x_152, 1, x_22);
+lean_ctor_set_usize(x_152, 2, x_20);
+lean_ctor_set(x_5, 0, x_152);
+x_153 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_153, 0, x_4);
+lean_ctor_set(x_153, 1, x_8);
+lean_ctor_set_uint64(x_153, sizeof(void*)*2, x_10);
+x_154 = lean_apply_1(x_3, x_153);
+return x_154;
+}
+case 1:
+{
+lean_object* x_155; 
+x_155 = lean_ctor_get(x_150, 0);
+lean_inc(x_155);
+switch (lean_obj_tag(x_155)) {
+case 0:
+{
+lean_object* x_156; uint64_t x_157; lean_object* x_158; size_t x_159; lean_object* x_160; lean_object* x_161; size_t x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; 
+x_156 = lean_ctor_get(x_8, 1);
+lean_inc(x_156);
+x_157 = lean_ctor_get_uint64(x_8, sizeof(void*)*2);
+x_158 = lean_ctor_get(x_147, 1);
+lean_inc(x_158);
+x_159 = lean_ctor_get_usize(x_147, 2);
+if (lean_is_exclusive(x_147)) {
+ lean_ctor_release(x_147, 0);
+ lean_ctor_release(x_147, 1);
+ x_160 = x_147;
+} else {
+ lean_dec_ref(x_147);
+ x_160 = lean_box(0);
+}
+x_161 = lean_ctor_get(x_150, 1);
+lean_inc(x_161);
+x_162 = lean_ctor_get_usize(x_150, 2);
+if (lean_is_exclusive(x_150)) {
+ lean_ctor_release(x_150, 0);
+ lean_ctor_release(x_150, 1);
+ x_163 = x_150;
+} else {
+ lean_dec_ref(x_150);
+ x_163 = lean_box(0);
+}
+x_164 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+x_165 = lean_string_dec_eq(x_161, x_164);
+lean_dec(x_161);
+if (x_165 == 0)
+{
+lean_object* x_166; lean_object* x_167; lean_object* x_168; 
+lean_dec(x_160);
+lean_dec(x_158);
+lean_dec(x_156);
+lean_free_object(x_6);
+lean_dec(x_2);
+if (lean_is_scalar(x_163)) {
+ x_166 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_166 = x_163;
+}
+lean_ctor_set(x_166, 0, x_155);
+lean_ctor_set(x_166, 1, x_22);
+lean_ctor_set_usize(x_166, 2, x_20);
+lean_ctor_set(x_5, 0, x_166);
+x_167 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_167, 0, x_4);
+lean_ctor_set(x_167, 1, x_8);
+lean_ctor_set_uint64(x_167, sizeof(void*)*2, x_10);
+x_168 = lean_apply_1(x_3, x_167);
+return x_168;
+}
+else
+{
+lean_object* x_169; lean_object* x_170; uint8_t x_171; 
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_169 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_169 = lean_box(0);
+}
+x_170 = l_Bool_HasRepr___closed__2;
+x_171 = lean_string_dec_eq(x_158, x_170);
+if (x_171 == 0)
+{
+lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; 
+lean_dec(x_2);
+if (lean_is_scalar(x_163)) {
+ x_172 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_172 = x_163;
+}
+lean_ctor_set(x_172, 0, x_155);
+lean_ctor_set(x_172, 1, x_22);
+lean_ctor_set_usize(x_172, 2, x_20);
+if (lean_is_scalar(x_169)) {
+ x_173 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_173 = x_169;
+}
+lean_ctor_set(x_173, 0, x_172);
+lean_ctor_set(x_173, 1, x_15);
+lean_ctor_set_uint64(x_173, sizeof(void*)*2, x_16);
+lean_ctor_set_tag(x_5, 5);
+lean_ctor_set(x_5, 1, x_11);
+lean_ctor_set(x_5, 0, x_173);
+lean_ctor_set_uint64(x_5, sizeof(void*)*2, x_12);
+if (lean_is_scalar(x_160)) {
+ x_174 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_174 = x_160;
+}
+lean_ctor_set(x_174, 0, x_155);
+lean_ctor_set(x_174, 1, x_164);
+lean_ctor_set_usize(x_174, 2, x_162);
+lean_ctor_set(x_6, 1, x_158);
+lean_ctor_set(x_6, 0, x_174);
+lean_ctor_set_usize(x_6, 2, x_159);
+lean_ctor_set_tag(x_4, 4);
+lean_ctor_set(x_4, 1, x_156);
+lean_ctor_set(x_4, 0, x_6);
+lean_ctor_set_uint64(x_4, sizeof(void*)*2, x_157);
+x_175 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_175, 0, x_5);
+lean_ctor_set(x_175, 1, x_4);
+lean_ctor_set_uint64(x_175, sizeof(void*)*2, x_10);
+x_176 = lean_apply_1(x_3, x_175);
+return x_176;
+}
+else
+{
+lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; 
+lean_dec(x_169);
+lean_dec(x_163);
+lean_dec(x_160);
+lean_dec(x_158);
+lean_free_object(x_6);
+lean_free_object(x_5);
+lean_free_object(x_4);
+lean_dec(x_3);
+x_177 = lean_box_uint64(x_16);
+x_178 = lean_box_uint64(x_12);
+x_179 = lean_box_uint64(x_157);
+x_180 = lean_box_uint64(x_10);
+x_181 = lean_box_usize(x_20);
+x_182 = lean_box_usize(x_162);
+x_183 = lean_box_usize(x_159);
+x_184 = lean_apply_10(x_2, x_15, x_177, x_11, x_178, x_156, x_179, x_180, x_181, x_182, x_183);
+return x_184;
+}
+}
+}
+case 1:
+{
+lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; 
+lean_dec(x_150);
+lean_dec(x_147);
+lean_free_object(x_6);
+lean_dec(x_2);
+if (lean_is_exclusive(x_155)) {
+ lean_ctor_release(x_155, 0);
+ lean_ctor_release(x_155, 1);
+ x_185 = x_155;
+} else {
+ lean_dec_ref(x_155);
+ x_185 = lean_box(0);
+}
+if (lean_is_scalar(x_185)) {
+ x_186 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_186 = x_185;
+}
+lean_ctor_set(x_186, 0, x_7);
+lean_ctor_set(x_186, 1, x_22);
+lean_ctor_set_usize(x_186, 2, x_20);
+lean_ctor_set(x_5, 0, x_186);
+x_187 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_187, 0, x_4);
+lean_ctor_set(x_187, 1, x_8);
+lean_ctor_set_uint64(x_187, sizeof(void*)*2, x_10);
+x_188 = lean_apply_1(x_3, x_187);
+return x_188;
+}
+default: 
+{
+lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; 
+lean_dec(x_150);
+lean_dec(x_147);
+lean_free_object(x_6);
+lean_dec(x_2);
+if (lean_is_exclusive(x_155)) {
+ lean_ctor_release(x_155, 0);
+ lean_ctor_release(x_155, 1);
+ x_189 = x_155;
+} else {
+ lean_dec_ref(x_155);
+ x_189 = lean_box(0);
+}
+if (lean_is_scalar(x_189)) {
+ x_190 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_190 = x_189;
+ lean_ctor_set_tag(x_190, 1);
+}
+lean_ctor_set(x_190, 0, x_7);
+lean_ctor_set(x_190, 1, x_22);
+lean_ctor_set_usize(x_190, 2, x_20);
+lean_ctor_set(x_5, 0, x_190);
+x_191 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_191, 0, x_4);
+lean_ctor_set(x_191, 1, x_8);
+lean_ctor_set_uint64(x_191, sizeof(void*)*2, x_10);
+x_192 = lean_apply_1(x_3, x_191);
+return x_192;
+}
+}
+}
+default: 
+{
+lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; 
+lean_dec(x_147);
+lean_free_object(x_6);
+lean_dec(x_2);
+if (lean_is_exclusive(x_150)) {
+ lean_ctor_release(x_150, 0);
+ lean_ctor_release(x_150, 1);
+ x_193 = x_150;
+} else {
+ lean_dec_ref(x_150);
+ x_193 = lean_box(0);
+}
+if (lean_is_scalar(x_193)) {
+ x_194 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_194 = x_193;
+ lean_ctor_set_tag(x_194, 1);
+}
+lean_ctor_set(x_194, 0, x_7);
+lean_ctor_set(x_194, 1, x_22);
+lean_ctor_set_usize(x_194, 2, x_20);
+lean_ctor_set(x_5, 0, x_194);
+x_195 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_195, 0, x_4);
+lean_ctor_set(x_195, 1, x_8);
+lean_ctor_set_uint64(x_195, sizeof(void*)*2, x_10);
+x_196 = lean_apply_1(x_3, x_195);
+return x_196;
+}
+}
+}
+default: 
+{
+lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; 
+lean_free_object(x_6);
+lean_dec(x_2);
+if (lean_is_exclusive(x_147)) {
+ lean_ctor_release(x_147, 0);
+ lean_ctor_release(x_147, 1);
+ x_197 = x_147;
+} else {
+ lean_dec_ref(x_147);
+ x_197 = lean_box(0);
+}
+if (lean_is_scalar(x_197)) {
+ x_198 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_198 = x_197;
+ lean_ctor_set_tag(x_198, 1);
+}
+lean_ctor_set(x_198, 0, x_7);
+lean_ctor_set(x_198, 1, x_22);
+lean_ctor_set_usize(x_198, 2, x_20);
+lean_ctor_set(x_5, 0, x_198);
+x_199 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_199, 0, x_4);
+lean_ctor_set(x_199, 1, x_8);
+lean_ctor_set_uint64(x_199, sizeof(void*)*2, x_10);
+x_200 = lean_apply_1(x_3, x_199);
+return x_200;
+}
+}
+}
+else
+{
+lean_object* x_201; lean_object* x_202; 
+lean_dec(x_2);
+lean_ctor_set(x_6, 1, x_22);
+x_201 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_201, 0, x_4);
+lean_ctor_set(x_201, 1, x_8);
+lean_ctor_set_uint64(x_201, sizeof(void*)*2, x_10);
+x_202 = lean_apply_1(x_3, x_201);
+return x_202;
+}
+}
+}
+}
+else
+{
+lean_object* x_203; size_t x_204; lean_object* x_205; uint8_t x_206; 
+x_203 = lean_ctor_get(x_6, 1);
+x_204 = lean_ctor_get_usize(x_6, 2);
+lean_inc(x_203);
+lean_dec(x_6);
+x_205 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
+x_206 = lean_string_dec_eq(x_203, x_205);
+lean_dec(x_203);
+if (x_206 == 0)
+{
+lean_object* x_207; 
+lean_free_object(x_5);
+lean_dec(x_15);
+lean_free_object(x_4);
+lean_dec(x_11);
+lean_dec(x_8);
+lean_dec(x_2);
+x_207 = lean_apply_1(x_3, x_1);
+return x_207;
+}
+else
+{
+lean_object* x_208; 
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ x_208 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_208 = lean_box(0);
+}
+if (lean_obj_tag(x_8) == 4)
+{
+lean_object* x_209; 
+x_209 = lean_ctor_get(x_8, 0);
+lean_inc(x_209);
+switch (lean_obj_tag(x_209)) {
+case 0:
+{
+lean_object* x_210; lean_object* x_211; lean_object* x_212; 
+lean_dec(x_2);
+x_210 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_210, 0, x_209);
+lean_ctor_set(x_210, 1, x_205);
+lean_ctor_set_usize(x_210, 2, x_204);
+lean_ctor_set(x_5, 0, x_210);
+if (lean_is_scalar(x_208)) {
+ x_211 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_211 = x_208;
+}
+lean_ctor_set(x_211, 0, x_4);
+lean_ctor_set(x_211, 1, x_8);
+lean_ctor_set_uint64(x_211, sizeof(void*)*2, x_10);
+x_212 = lean_apply_1(x_3, x_211);
+return x_212;
+}
+case 1:
+{
+lean_object* x_213; 
+x_213 = lean_ctor_get(x_209, 0);
+lean_inc(x_213);
+switch (lean_obj_tag(x_213)) {
+case 0:
+{
+lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; 
+lean_dec(x_2);
+if (lean_is_exclusive(x_209)) {
+ lean_ctor_release(x_209, 0);
+ lean_ctor_release(x_209, 1);
+ x_214 = x_209;
+} else {
+ lean_dec_ref(x_209);
+ x_214 = lean_box(0);
+}
+if (lean_is_scalar(x_214)) {
+ x_215 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_215 = x_214;
+}
+lean_ctor_set(x_215, 0, x_213);
+lean_ctor_set(x_215, 1, x_205);
+lean_ctor_set_usize(x_215, 2, x_204);
+lean_ctor_set(x_5, 0, x_215);
+if (lean_is_scalar(x_208)) {
+ x_216 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_216 = x_208;
+}
+lean_ctor_set(x_216, 0, x_4);
+lean_ctor_set(x_216, 1, x_8);
+lean_ctor_set_uint64(x_216, sizeof(void*)*2, x_10);
+x_217 = lean_apply_1(x_3, x_216);
+return x_217;
+}
+case 1:
+{
+lean_object* x_218; 
+x_218 = lean_ctor_get(x_213, 0);
+lean_inc(x_218);
+switch (lean_obj_tag(x_218)) {
+case 0:
+{
+lean_object* x_219; uint64_t x_220; lean_object* x_221; size_t x_222; lean_object* x_223; lean_object* x_224; size_t x_225; lean_object* x_226; lean_object* x_227; uint8_t x_228; 
+x_219 = lean_ctor_get(x_8, 1);
+lean_inc(x_219);
+x_220 = lean_ctor_get_uint64(x_8, sizeof(void*)*2);
+x_221 = lean_ctor_get(x_209, 1);
+lean_inc(x_221);
+x_222 = lean_ctor_get_usize(x_209, 2);
+if (lean_is_exclusive(x_209)) {
+ lean_ctor_release(x_209, 0);
+ lean_ctor_release(x_209, 1);
+ x_223 = x_209;
+} else {
+ lean_dec_ref(x_209);
+ x_223 = lean_box(0);
+}
+x_224 = lean_ctor_get(x_213, 1);
+lean_inc(x_224);
+x_225 = lean_ctor_get_usize(x_213, 2);
+if (lean_is_exclusive(x_213)) {
+ lean_ctor_release(x_213, 0);
+ lean_ctor_release(x_213, 1);
+ x_226 = x_213;
+} else {
+ lean_dec_ref(x_213);
+ x_226 = lean_box(0);
+}
+x_227 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+x_228 = lean_string_dec_eq(x_224, x_227);
+lean_dec(x_224);
+if (x_228 == 0)
+{
+lean_object* x_229; lean_object* x_230; lean_object* x_231; 
+lean_dec(x_223);
+lean_dec(x_221);
+lean_dec(x_219);
+lean_dec(x_2);
+if (lean_is_scalar(x_226)) {
+ x_229 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_229 = x_226;
+}
+lean_ctor_set(x_229, 0, x_218);
+lean_ctor_set(x_229, 1, x_205);
+lean_ctor_set_usize(x_229, 2, x_204);
+lean_ctor_set(x_5, 0, x_229);
+if (lean_is_scalar(x_208)) {
+ x_230 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_230 = x_208;
+}
+lean_ctor_set(x_230, 0, x_4);
+lean_ctor_set(x_230, 1, x_8);
+lean_ctor_set_uint64(x_230, sizeof(void*)*2, x_10);
+x_231 = lean_apply_1(x_3, x_230);
+return x_231;
+}
+else
+{
+lean_object* x_232; lean_object* x_233; uint8_t x_234; 
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_232 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_232 = lean_box(0);
+}
+x_233 = l_Bool_HasRepr___closed__2;
+x_234 = lean_string_dec_eq(x_221, x_233);
+if (x_234 == 0)
+{
+lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; 
+lean_dec(x_2);
+if (lean_is_scalar(x_226)) {
+ x_235 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_235 = x_226;
+}
+lean_ctor_set(x_235, 0, x_218);
+lean_ctor_set(x_235, 1, x_205);
+lean_ctor_set_usize(x_235, 2, x_204);
+if (lean_is_scalar(x_232)) {
+ x_236 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_236 = x_232;
+}
+lean_ctor_set(x_236, 0, x_235);
+lean_ctor_set(x_236, 1, x_15);
+lean_ctor_set_uint64(x_236, sizeof(void*)*2, x_16);
+lean_ctor_set_tag(x_5, 5);
+lean_ctor_set(x_5, 1, x_11);
+lean_ctor_set(x_5, 0, x_236);
+lean_ctor_set_uint64(x_5, sizeof(void*)*2, x_12);
+if (lean_is_scalar(x_223)) {
+ x_237 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_237 = x_223;
+}
+lean_ctor_set(x_237, 0, x_218);
+lean_ctor_set(x_237, 1, x_227);
+lean_ctor_set_usize(x_237, 2, x_225);
+x_238 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_238, 0, x_237);
+lean_ctor_set(x_238, 1, x_221);
+lean_ctor_set_usize(x_238, 2, x_222);
+lean_ctor_set_tag(x_4, 4);
+lean_ctor_set(x_4, 1, x_219);
+lean_ctor_set(x_4, 0, x_238);
+lean_ctor_set_uint64(x_4, sizeof(void*)*2, x_220);
+if (lean_is_scalar(x_208)) {
+ x_239 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_239 = x_208;
+}
+lean_ctor_set(x_239, 0, x_5);
+lean_ctor_set(x_239, 1, x_4);
+lean_ctor_set_uint64(x_239, sizeof(void*)*2, x_10);
+x_240 = lean_apply_1(x_3, x_239);
+return x_240;
+}
+else
+{
+lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; 
+lean_dec(x_232);
+lean_dec(x_226);
+lean_dec(x_223);
+lean_dec(x_221);
+lean_dec(x_208);
+lean_free_object(x_5);
+lean_free_object(x_4);
+lean_dec(x_3);
+x_241 = lean_box_uint64(x_16);
+x_242 = lean_box_uint64(x_12);
+x_243 = lean_box_uint64(x_220);
+x_244 = lean_box_uint64(x_10);
+x_245 = lean_box_usize(x_204);
+x_246 = lean_box_usize(x_225);
+x_247 = lean_box_usize(x_222);
+x_248 = lean_apply_10(x_2, x_15, x_241, x_11, x_242, x_219, x_243, x_244, x_245, x_246, x_247);
+return x_248;
+}
+}
+}
+case 1:
+{
+lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; 
+lean_dec(x_213);
+lean_dec(x_209);
+lean_dec(x_2);
+if (lean_is_exclusive(x_218)) {
+ lean_ctor_release(x_218, 0);
+ lean_ctor_release(x_218, 1);
+ x_249 = x_218;
+} else {
+ lean_dec_ref(x_218);
+ x_249 = lean_box(0);
+}
+if (lean_is_scalar(x_249)) {
+ x_250 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_250 = x_249;
+}
+lean_ctor_set(x_250, 0, x_7);
+lean_ctor_set(x_250, 1, x_205);
+lean_ctor_set_usize(x_250, 2, x_204);
+lean_ctor_set(x_5, 0, x_250);
+if (lean_is_scalar(x_208)) {
+ x_251 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_251 = x_208;
+}
+lean_ctor_set(x_251, 0, x_4);
+lean_ctor_set(x_251, 1, x_8);
+lean_ctor_set_uint64(x_251, sizeof(void*)*2, x_10);
+x_252 = lean_apply_1(x_3, x_251);
+return x_252;
+}
+default: 
+{
+lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; 
+lean_dec(x_213);
+lean_dec(x_209);
+lean_dec(x_2);
+if (lean_is_exclusive(x_218)) {
+ lean_ctor_release(x_218, 0);
+ lean_ctor_release(x_218, 1);
+ x_253 = x_218;
+} else {
+ lean_dec_ref(x_218);
+ x_253 = lean_box(0);
+}
+if (lean_is_scalar(x_253)) {
+ x_254 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_254 = x_253;
+ lean_ctor_set_tag(x_254, 1);
+}
+lean_ctor_set(x_254, 0, x_7);
+lean_ctor_set(x_254, 1, x_205);
+lean_ctor_set_usize(x_254, 2, x_204);
+lean_ctor_set(x_5, 0, x_254);
+if (lean_is_scalar(x_208)) {
+ x_255 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_255 = x_208;
+}
+lean_ctor_set(x_255, 0, x_4);
+lean_ctor_set(x_255, 1, x_8);
+lean_ctor_set_uint64(x_255, sizeof(void*)*2, x_10);
+x_256 = lean_apply_1(x_3, x_255);
+return x_256;
+}
+}
+}
+default: 
+{
+lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; 
+lean_dec(x_209);
+lean_dec(x_2);
+if (lean_is_exclusive(x_213)) {
+ lean_ctor_release(x_213, 0);
+ lean_ctor_release(x_213, 1);
+ x_257 = x_213;
+} else {
+ lean_dec_ref(x_213);
+ x_257 = lean_box(0);
+}
+if (lean_is_scalar(x_257)) {
+ x_258 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_258 = x_257;
+ lean_ctor_set_tag(x_258, 1);
+}
+lean_ctor_set(x_258, 0, x_7);
+lean_ctor_set(x_258, 1, x_205);
+lean_ctor_set_usize(x_258, 2, x_204);
+lean_ctor_set(x_5, 0, x_258);
+if (lean_is_scalar(x_208)) {
+ x_259 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_259 = x_208;
+}
+lean_ctor_set(x_259, 0, x_4);
+lean_ctor_set(x_259, 1, x_8);
+lean_ctor_set_uint64(x_259, sizeof(void*)*2, x_10);
+x_260 = lean_apply_1(x_3, x_259);
+return x_260;
+}
+}
+}
+default: 
+{
+lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; 
+lean_dec(x_2);
+if (lean_is_exclusive(x_209)) {
+ lean_ctor_release(x_209, 0);
+ lean_ctor_release(x_209, 1);
+ x_261 = x_209;
+} else {
+ lean_dec_ref(x_209);
+ x_261 = lean_box(0);
+}
+if (lean_is_scalar(x_261)) {
+ x_262 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_262 = x_261;
+ lean_ctor_set_tag(x_262, 1);
+}
+lean_ctor_set(x_262, 0, x_7);
+lean_ctor_set(x_262, 1, x_205);
+lean_ctor_set_usize(x_262, 2, x_204);
+lean_ctor_set(x_5, 0, x_262);
+if (lean_is_scalar(x_208)) {
+ x_263 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_263 = x_208;
+}
+lean_ctor_set(x_263, 0, x_4);
+lean_ctor_set(x_263, 1, x_8);
+lean_ctor_set_uint64(x_263, sizeof(void*)*2, x_10);
+x_264 = lean_apply_1(x_3, x_263);
+return x_264;
+}
+}
+}
+else
+{
+lean_object* x_265; lean_object* x_266; lean_object* x_267; 
+lean_dec(x_2);
+x_265 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+lean_ctor_set(x_265, 0, x_7);
+lean_ctor_set(x_265, 1, x_205);
+lean_ctor_set_usize(x_265, 2, x_204);
+lean_ctor_set(x_5, 0, x_265);
+if (lean_is_scalar(x_208)) {
+ x_266 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_266 = x_208;
+}
+lean_ctor_set(x_266, 0, x_4);
+lean_ctor_set(x_266, 1, x_8);
+lean_ctor_set_uint64(x_266, sizeof(void*)*2, x_10);
+x_267 = lean_apply_1(x_3, x_266);
+return x_267;
+}
+}
+}
+}
+else
+{
+lean_object* x_268; uint64_t x_269; lean_object* x_270; size_t x_271; lean_object* x_272; lean_object* x_273; uint8_t x_274; 
+x_268 = lean_ctor_get(x_5, 1);
+x_269 = lean_ctor_get_uint64(x_5, sizeof(void*)*2);
+lean_inc(x_268);
+lean_dec(x_5);
+x_270 = lean_ctor_get(x_6, 1);
+lean_inc(x_270);
+x_271 = lean_ctor_get_usize(x_6, 2);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ x_272 = x_6;
+} else {
+ lean_dec_ref(x_6);
+ x_272 = lean_box(0);
+}
+x_273 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
+x_274 = lean_string_dec_eq(x_270, x_273);
+lean_dec(x_270);
+if (x_274 == 0)
+{
+lean_object* x_275; 
+lean_dec(x_272);
+lean_dec(x_268);
+lean_free_object(x_4);
+lean_dec(x_11);
+lean_dec(x_8);
+lean_dec(x_2);
+x_275 = lean_apply_1(x_3, x_1);
+return x_275;
+}
+else
+{
+lean_object* x_276; 
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ x_276 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_276 = lean_box(0);
+}
+if (lean_obj_tag(x_8) == 4)
+{
+lean_object* x_277; 
+x_277 = lean_ctor_get(x_8, 0);
+lean_inc(x_277);
+switch (lean_obj_tag(x_277)) {
+case 0:
+{
+lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; 
+lean_dec(x_2);
+if (lean_is_scalar(x_272)) {
+ x_278 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_278 = x_272;
+}
+lean_ctor_set(x_278, 0, x_277);
+lean_ctor_set(x_278, 1, x_273);
+lean_ctor_set_usize(x_278, 2, x_271);
+x_279 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_279, 0, x_278);
+lean_ctor_set(x_279, 1, x_268);
+lean_ctor_set_uint64(x_279, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_279);
+if (lean_is_scalar(x_276)) {
+ x_280 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_280 = x_276;
+}
+lean_ctor_set(x_280, 0, x_4);
+lean_ctor_set(x_280, 1, x_8);
+lean_ctor_set_uint64(x_280, sizeof(void*)*2, x_10);
+x_281 = lean_apply_1(x_3, x_280);
+return x_281;
+}
+case 1:
+{
+lean_object* x_282; 
+x_282 = lean_ctor_get(x_277, 0);
+lean_inc(x_282);
+switch (lean_obj_tag(x_282)) {
+case 0:
+{
+lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; 
+lean_dec(x_272);
+lean_dec(x_2);
+if (lean_is_exclusive(x_277)) {
+ lean_ctor_release(x_277, 0);
+ lean_ctor_release(x_277, 1);
+ x_283 = x_277;
+} else {
+ lean_dec_ref(x_277);
+ x_283 = lean_box(0);
+}
+if (lean_is_scalar(x_283)) {
+ x_284 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_284 = x_283;
+}
+lean_ctor_set(x_284, 0, x_282);
+lean_ctor_set(x_284, 1, x_273);
+lean_ctor_set_usize(x_284, 2, x_271);
+x_285 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_285, 0, x_284);
+lean_ctor_set(x_285, 1, x_268);
+lean_ctor_set_uint64(x_285, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_285);
+if (lean_is_scalar(x_276)) {
+ x_286 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_286 = x_276;
+}
+lean_ctor_set(x_286, 0, x_4);
+lean_ctor_set(x_286, 1, x_8);
+lean_ctor_set_uint64(x_286, sizeof(void*)*2, x_10);
+x_287 = lean_apply_1(x_3, x_286);
+return x_287;
+}
+case 1:
+{
+lean_object* x_288; 
+x_288 = lean_ctor_get(x_282, 0);
+lean_inc(x_288);
+switch (lean_obj_tag(x_288)) {
+case 0:
+{
+lean_object* x_289; uint64_t x_290; lean_object* x_291; size_t x_292; lean_object* x_293; lean_object* x_294; size_t x_295; lean_object* x_296; lean_object* x_297; uint8_t x_298; 
+x_289 = lean_ctor_get(x_8, 1);
+lean_inc(x_289);
+x_290 = lean_ctor_get_uint64(x_8, sizeof(void*)*2);
+x_291 = lean_ctor_get(x_277, 1);
+lean_inc(x_291);
+x_292 = lean_ctor_get_usize(x_277, 2);
+if (lean_is_exclusive(x_277)) {
+ lean_ctor_release(x_277, 0);
+ lean_ctor_release(x_277, 1);
+ x_293 = x_277;
+} else {
+ lean_dec_ref(x_277);
+ x_293 = lean_box(0);
+}
+x_294 = lean_ctor_get(x_282, 1);
+lean_inc(x_294);
+x_295 = lean_ctor_get_usize(x_282, 2);
+if (lean_is_exclusive(x_282)) {
+ lean_ctor_release(x_282, 0);
+ lean_ctor_release(x_282, 1);
+ x_296 = x_282;
+} else {
+ lean_dec_ref(x_282);
+ x_296 = lean_box(0);
+}
+x_297 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+x_298 = lean_string_dec_eq(x_294, x_297);
+lean_dec(x_294);
+if (x_298 == 0)
+{
+lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; 
+lean_dec(x_293);
+lean_dec(x_291);
+lean_dec(x_289);
+lean_dec(x_272);
+lean_dec(x_2);
+if (lean_is_scalar(x_296)) {
+ x_299 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_299 = x_296;
+}
+lean_ctor_set(x_299, 0, x_288);
+lean_ctor_set(x_299, 1, x_273);
+lean_ctor_set_usize(x_299, 2, x_271);
+x_300 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_300, 0, x_299);
+lean_ctor_set(x_300, 1, x_268);
+lean_ctor_set_uint64(x_300, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_300);
+if (lean_is_scalar(x_276)) {
+ x_301 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_301 = x_276;
+}
+lean_ctor_set(x_301, 0, x_4);
+lean_ctor_set(x_301, 1, x_8);
+lean_ctor_set_uint64(x_301, sizeof(void*)*2, x_10);
+x_302 = lean_apply_1(x_3, x_301);
+return x_302;
+}
+else
+{
+lean_object* x_303; lean_object* x_304; uint8_t x_305; 
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_303 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_303 = lean_box(0);
+}
+x_304 = l_Bool_HasRepr___closed__2;
+x_305 = lean_string_dec_eq(x_291, x_304);
+if (x_305 == 0)
+{
+lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; lean_object* x_312; 
+lean_dec(x_2);
+if (lean_is_scalar(x_296)) {
+ x_306 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_306 = x_296;
+}
+lean_ctor_set(x_306, 0, x_288);
+lean_ctor_set(x_306, 1, x_273);
+lean_ctor_set_usize(x_306, 2, x_271);
+if (lean_is_scalar(x_303)) {
+ x_307 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_307 = x_303;
+}
+lean_ctor_set(x_307, 0, x_306);
+lean_ctor_set(x_307, 1, x_268);
+lean_ctor_set_uint64(x_307, sizeof(void*)*2, x_269);
+x_308 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_308, 0, x_307);
+lean_ctor_set(x_308, 1, x_11);
+lean_ctor_set_uint64(x_308, sizeof(void*)*2, x_12);
+if (lean_is_scalar(x_293)) {
+ x_309 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_309 = x_293;
+}
+lean_ctor_set(x_309, 0, x_288);
+lean_ctor_set(x_309, 1, x_297);
+lean_ctor_set_usize(x_309, 2, x_295);
+if (lean_is_scalar(x_272)) {
+ x_310 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_310 = x_272;
+}
+lean_ctor_set(x_310, 0, x_309);
+lean_ctor_set(x_310, 1, x_291);
+lean_ctor_set_usize(x_310, 2, x_292);
+lean_ctor_set_tag(x_4, 4);
+lean_ctor_set(x_4, 1, x_289);
+lean_ctor_set(x_4, 0, x_310);
+lean_ctor_set_uint64(x_4, sizeof(void*)*2, x_290);
+if (lean_is_scalar(x_276)) {
+ x_311 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_311 = x_276;
+}
+lean_ctor_set(x_311, 0, x_308);
+lean_ctor_set(x_311, 1, x_4);
+lean_ctor_set_uint64(x_311, sizeof(void*)*2, x_10);
+x_312 = lean_apply_1(x_3, x_311);
+return x_312;
+}
+else
+{
+lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; 
+lean_dec(x_303);
+lean_dec(x_296);
+lean_dec(x_293);
+lean_dec(x_291);
+lean_dec(x_276);
+lean_dec(x_272);
+lean_free_object(x_4);
+lean_dec(x_3);
+x_313 = lean_box_uint64(x_269);
+x_314 = lean_box_uint64(x_12);
+x_315 = lean_box_uint64(x_290);
+x_316 = lean_box_uint64(x_10);
+x_317 = lean_box_usize(x_271);
+x_318 = lean_box_usize(x_295);
+x_319 = lean_box_usize(x_292);
+x_320 = lean_apply_10(x_2, x_268, x_313, x_11, x_314, x_289, x_315, x_316, x_317, x_318, x_319);
+return x_320;
+}
+}
+}
+case 1:
+{
+lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; 
+lean_dec(x_282);
+lean_dec(x_277);
+lean_dec(x_272);
+lean_dec(x_2);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ x_321 = x_288;
+} else {
+ lean_dec_ref(x_288);
+ x_321 = lean_box(0);
+}
+if (lean_is_scalar(x_321)) {
+ x_322 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_322 = x_321;
+}
+lean_ctor_set(x_322, 0, x_7);
+lean_ctor_set(x_322, 1, x_273);
+lean_ctor_set_usize(x_322, 2, x_271);
+x_323 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_323, 0, x_322);
+lean_ctor_set(x_323, 1, x_268);
+lean_ctor_set_uint64(x_323, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_323);
+if (lean_is_scalar(x_276)) {
+ x_324 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_324 = x_276;
+}
+lean_ctor_set(x_324, 0, x_4);
+lean_ctor_set(x_324, 1, x_8);
+lean_ctor_set_uint64(x_324, sizeof(void*)*2, x_10);
+x_325 = lean_apply_1(x_3, x_324);
+return x_325;
+}
+default: 
+{
+lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; 
+lean_dec(x_282);
+lean_dec(x_277);
+lean_dec(x_272);
+lean_dec(x_2);
+if (lean_is_exclusive(x_288)) {
+ lean_ctor_release(x_288, 0);
+ lean_ctor_release(x_288, 1);
+ x_326 = x_288;
+} else {
+ lean_dec_ref(x_288);
+ x_326 = lean_box(0);
+}
+if (lean_is_scalar(x_326)) {
+ x_327 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_327 = x_326;
+ lean_ctor_set_tag(x_327, 1);
+}
+lean_ctor_set(x_327, 0, x_7);
+lean_ctor_set(x_327, 1, x_273);
+lean_ctor_set_usize(x_327, 2, x_271);
+x_328 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_328, 0, x_327);
+lean_ctor_set(x_328, 1, x_268);
+lean_ctor_set_uint64(x_328, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_328);
+if (lean_is_scalar(x_276)) {
+ x_329 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_329 = x_276;
+}
+lean_ctor_set(x_329, 0, x_4);
+lean_ctor_set(x_329, 1, x_8);
+lean_ctor_set_uint64(x_329, sizeof(void*)*2, x_10);
+x_330 = lean_apply_1(x_3, x_329);
+return x_330;
+}
+}
+}
+default: 
+{
+lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; 
+lean_dec(x_277);
+lean_dec(x_272);
+lean_dec(x_2);
+if (lean_is_exclusive(x_282)) {
+ lean_ctor_release(x_282, 0);
+ lean_ctor_release(x_282, 1);
+ x_331 = x_282;
+} else {
+ lean_dec_ref(x_282);
+ x_331 = lean_box(0);
+}
+if (lean_is_scalar(x_331)) {
+ x_332 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_332 = x_331;
+ lean_ctor_set_tag(x_332, 1);
+}
+lean_ctor_set(x_332, 0, x_7);
+lean_ctor_set(x_332, 1, x_273);
+lean_ctor_set_usize(x_332, 2, x_271);
+x_333 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_333, 0, x_332);
+lean_ctor_set(x_333, 1, x_268);
+lean_ctor_set_uint64(x_333, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_333);
+if (lean_is_scalar(x_276)) {
+ x_334 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_334 = x_276;
+}
+lean_ctor_set(x_334, 0, x_4);
+lean_ctor_set(x_334, 1, x_8);
+lean_ctor_set_uint64(x_334, sizeof(void*)*2, x_10);
+x_335 = lean_apply_1(x_3, x_334);
+return x_335;
+}
+}
+}
+default: 
+{
+lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; 
+lean_dec(x_272);
+lean_dec(x_2);
+if (lean_is_exclusive(x_277)) {
+ lean_ctor_release(x_277, 0);
+ lean_ctor_release(x_277, 1);
+ x_336 = x_277;
+} else {
+ lean_dec_ref(x_277);
+ x_336 = lean_box(0);
+}
+if (lean_is_scalar(x_336)) {
+ x_337 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_337 = x_336;
+ lean_ctor_set_tag(x_337, 1);
+}
+lean_ctor_set(x_337, 0, x_7);
+lean_ctor_set(x_337, 1, x_273);
+lean_ctor_set_usize(x_337, 2, x_271);
+x_338 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_338, 0, x_337);
+lean_ctor_set(x_338, 1, x_268);
+lean_ctor_set_uint64(x_338, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_338);
+if (lean_is_scalar(x_276)) {
+ x_339 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_339 = x_276;
+}
+lean_ctor_set(x_339, 0, x_4);
+lean_ctor_set(x_339, 1, x_8);
+lean_ctor_set_uint64(x_339, sizeof(void*)*2, x_10);
+x_340 = lean_apply_1(x_3, x_339);
+return x_340;
+}
+}
+}
+else
+{
+lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; 
+lean_dec(x_2);
+if (lean_is_scalar(x_272)) {
+ x_341 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_341 = x_272;
+}
+lean_ctor_set(x_341, 0, x_7);
+lean_ctor_set(x_341, 1, x_273);
+lean_ctor_set_usize(x_341, 2, x_271);
+x_342 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_342, 0, x_341);
+lean_ctor_set(x_342, 1, x_268);
+lean_ctor_set_uint64(x_342, sizeof(void*)*2, x_269);
+lean_ctor_set(x_4, 0, x_342);
+if (lean_is_scalar(x_276)) {
+ x_343 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_343 = x_276;
+}
+lean_ctor_set(x_343, 0, x_4);
+lean_ctor_set(x_343, 1, x_8);
+lean_ctor_set_uint64(x_343, sizeof(void*)*2, x_10);
+x_344 = lean_apply_1(x_3, x_343);
+return x_344;
+}
+}
+}
+}
+else
+{
+uint64_t x_345; lean_object* x_346; uint64_t x_347; lean_object* x_348; uint64_t x_349; lean_object* x_350; lean_object* x_351; size_t x_352; lean_object* x_353; lean_object* x_354; uint8_t x_355; 
+x_345 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+x_346 = lean_ctor_get(x_4, 1);
+x_347 = lean_ctor_get_uint64(x_4, sizeof(void*)*2);
+lean_inc(x_346);
+lean_dec(x_4);
+x_348 = lean_ctor_get(x_5, 1);
+lean_inc(x_348);
+x_349 = lean_ctor_get_uint64(x_5, sizeof(void*)*2);
+if (lean_is_exclusive(x_5)) {
+ lean_ctor_release(x_5, 0);
+ lean_ctor_release(x_5, 1);
+ x_350 = x_5;
+} else {
+ lean_dec_ref(x_5);
+ x_350 = lean_box(0);
+}
+x_351 = lean_ctor_get(x_6, 1);
+lean_inc(x_351);
+x_352 = lean_ctor_get_usize(x_6, 2);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ x_353 = x_6;
+} else {
+ lean_dec_ref(x_6);
+ x_353 = lean_box(0);
+}
+x_354 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
+x_355 = lean_string_dec_eq(x_351, x_354);
+lean_dec(x_351);
+if (x_355 == 0)
+{
+lean_object* x_356; 
+lean_dec(x_353);
+lean_dec(x_350);
+lean_dec(x_348);
+lean_dec(x_346);
+lean_dec(x_8);
+lean_dec(x_2);
+x_356 = lean_apply_1(x_3, x_1);
+return x_356;
+}
+else
+{
+lean_object* x_357; 
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ x_357 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_357 = lean_box(0);
+}
+if (lean_obj_tag(x_8) == 4)
+{
+lean_object* x_358; 
+x_358 = lean_ctor_get(x_8, 0);
+lean_inc(x_358);
+switch (lean_obj_tag(x_358)) {
+case 0:
+{
+lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; 
+lean_dec(x_2);
+if (lean_is_scalar(x_353)) {
+ x_359 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_359 = x_353;
+}
+lean_ctor_set(x_359, 0, x_358);
+lean_ctor_set(x_359, 1, x_354);
+lean_ctor_set_usize(x_359, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_360 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_360 = x_350;
+}
+lean_ctor_set(x_360, 0, x_359);
+lean_ctor_set(x_360, 1, x_348);
+lean_ctor_set_uint64(x_360, sizeof(void*)*2, x_349);
+x_361 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_361, 0, x_360);
+lean_ctor_set(x_361, 1, x_346);
+lean_ctor_set_uint64(x_361, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_362 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_362 = x_357;
+}
+lean_ctor_set(x_362, 0, x_361);
+lean_ctor_set(x_362, 1, x_8);
+lean_ctor_set_uint64(x_362, sizeof(void*)*2, x_345);
+x_363 = lean_apply_1(x_3, x_362);
+return x_363;
+}
+case 1:
+{
+lean_object* x_364; 
+x_364 = lean_ctor_get(x_358, 0);
+lean_inc(x_364);
+switch (lean_obj_tag(x_364)) {
+case 0:
+{
+lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; 
+lean_dec(x_353);
+lean_dec(x_2);
+if (lean_is_exclusive(x_358)) {
+ lean_ctor_release(x_358, 0);
+ lean_ctor_release(x_358, 1);
+ x_365 = x_358;
+} else {
+ lean_dec_ref(x_358);
+ x_365 = lean_box(0);
+}
+if (lean_is_scalar(x_365)) {
+ x_366 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_366 = x_365;
+}
+lean_ctor_set(x_366, 0, x_364);
+lean_ctor_set(x_366, 1, x_354);
+lean_ctor_set_usize(x_366, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_367 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_367 = x_350;
+}
+lean_ctor_set(x_367, 0, x_366);
+lean_ctor_set(x_367, 1, x_348);
+lean_ctor_set_uint64(x_367, sizeof(void*)*2, x_349);
+x_368 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_368, 0, x_367);
+lean_ctor_set(x_368, 1, x_346);
+lean_ctor_set_uint64(x_368, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_369 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_369 = x_357;
+}
+lean_ctor_set(x_369, 0, x_368);
+lean_ctor_set(x_369, 1, x_8);
+lean_ctor_set_uint64(x_369, sizeof(void*)*2, x_345);
+x_370 = lean_apply_1(x_3, x_369);
+return x_370;
+}
+case 1:
+{
+lean_object* x_371; 
+x_371 = lean_ctor_get(x_364, 0);
+lean_inc(x_371);
+switch (lean_obj_tag(x_371)) {
+case 0:
+{
+lean_object* x_372; uint64_t x_373; lean_object* x_374; size_t x_375; lean_object* x_376; lean_object* x_377; size_t x_378; lean_object* x_379; lean_object* x_380; uint8_t x_381; 
+x_372 = lean_ctor_get(x_8, 1);
+lean_inc(x_372);
+x_373 = lean_ctor_get_uint64(x_8, sizeof(void*)*2);
+x_374 = lean_ctor_get(x_358, 1);
+lean_inc(x_374);
+x_375 = lean_ctor_get_usize(x_358, 2);
+if (lean_is_exclusive(x_358)) {
+ lean_ctor_release(x_358, 0);
+ lean_ctor_release(x_358, 1);
+ x_376 = x_358;
+} else {
+ lean_dec_ref(x_358);
+ x_376 = lean_box(0);
+}
+x_377 = lean_ctor_get(x_364, 1);
+lean_inc(x_377);
+x_378 = lean_ctor_get_usize(x_364, 2);
+if (lean_is_exclusive(x_364)) {
+ lean_ctor_release(x_364, 0);
+ lean_ctor_release(x_364, 1);
+ x_379 = x_364;
+} else {
+ lean_dec_ref(x_364);
+ x_379 = lean_box(0);
+}
+x_380 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
+x_381 = lean_string_dec_eq(x_377, x_380);
+lean_dec(x_377);
+if (x_381 == 0)
+{
+lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; 
+lean_dec(x_376);
+lean_dec(x_374);
+lean_dec(x_372);
+lean_dec(x_353);
+lean_dec(x_2);
+if (lean_is_scalar(x_379)) {
+ x_382 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_382 = x_379;
+}
+lean_ctor_set(x_382, 0, x_371);
+lean_ctor_set(x_382, 1, x_354);
+lean_ctor_set_usize(x_382, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_383 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_383 = x_350;
+}
+lean_ctor_set(x_383, 0, x_382);
+lean_ctor_set(x_383, 1, x_348);
+lean_ctor_set_uint64(x_383, sizeof(void*)*2, x_349);
+x_384 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_384, 0, x_383);
+lean_ctor_set(x_384, 1, x_346);
+lean_ctor_set_uint64(x_384, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_385 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_385 = x_357;
+}
+lean_ctor_set(x_385, 0, x_384);
+lean_ctor_set(x_385, 1, x_8);
+lean_ctor_set_uint64(x_385, sizeof(void*)*2, x_345);
+x_386 = lean_apply_1(x_3, x_385);
+return x_386;
+}
+else
+{
+lean_object* x_387; lean_object* x_388; uint8_t x_389; 
+if (lean_is_exclusive(x_8)) {
+ lean_ctor_release(x_8, 0);
+ lean_ctor_release(x_8, 1);
+ x_387 = x_8;
+} else {
+ lean_dec_ref(x_8);
+ x_387 = lean_box(0);
+}
+x_388 = l_Bool_HasRepr___closed__2;
+x_389 = lean_string_dec_eq(x_374, x_388);
+if (x_389 == 0)
+{
+lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; 
+lean_dec(x_2);
+if (lean_is_scalar(x_379)) {
+ x_390 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_390 = x_379;
+}
+lean_ctor_set(x_390, 0, x_371);
+lean_ctor_set(x_390, 1, x_354);
+lean_ctor_set_usize(x_390, 2, x_352);
+if (lean_is_scalar(x_387)) {
+ x_391 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_391 = x_387;
+}
+lean_ctor_set(x_391, 0, x_390);
+lean_ctor_set(x_391, 1, x_348);
+lean_ctor_set_uint64(x_391, sizeof(void*)*2, x_349);
+if (lean_is_scalar(x_350)) {
+ x_392 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_392 = x_350;
+ lean_ctor_set_tag(x_392, 5);
+}
+lean_ctor_set(x_392, 0, x_391);
+lean_ctor_set(x_392, 1, x_346);
+lean_ctor_set_uint64(x_392, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_376)) {
+ x_393 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_393 = x_376;
+}
+lean_ctor_set(x_393, 0, x_371);
+lean_ctor_set(x_393, 1, x_380);
+lean_ctor_set_usize(x_393, 2, x_378);
+if (lean_is_scalar(x_353)) {
+ x_394 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_394 = x_353;
+}
+lean_ctor_set(x_394, 0, x_393);
+lean_ctor_set(x_394, 1, x_374);
+lean_ctor_set_usize(x_394, 2, x_375);
+x_395 = lean_alloc_ctor(4, 2, 8);
+lean_ctor_set(x_395, 0, x_394);
+lean_ctor_set(x_395, 1, x_372);
+lean_ctor_set_uint64(x_395, sizeof(void*)*2, x_373);
+if (lean_is_scalar(x_357)) {
+ x_396 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_396 = x_357;
+}
+lean_ctor_set(x_396, 0, x_392);
+lean_ctor_set(x_396, 1, x_395);
+lean_ctor_set_uint64(x_396, sizeof(void*)*2, x_345);
+x_397 = lean_apply_1(x_3, x_396);
+return x_397;
+}
+else
+{
+lean_object* x_398; lean_object* x_399; lean_object* x_400; lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; 
+lean_dec(x_387);
+lean_dec(x_379);
+lean_dec(x_376);
+lean_dec(x_374);
+lean_dec(x_357);
+lean_dec(x_353);
+lean_dec(x_350);
+lean_dec(x_3);
+x_398 = lean_box_uint64(x_349);
+x_399 = lean_box_uint64(x_347);
+x_400 = lean_box_uint64(x_373);
+x_401 = lean_box_uint64(x_345);
+x_402 = lean_box_usize(x_352);
+x_403 = lean_box_usize(x_378);
+x_404 = lean_box_usize(x_375);
+x_405 = lean_apply_10(x_2, x_348, x_398, x_346, x_399, x_372, x_400, x_401, x_402, x_403, x_404);
+return x_405;
+}
+}
+}
+case 1:
+{
+lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; lean_object* x_410; lean_object* x_411; 
+lean_dec(x_364);
+lean_dec(x_358);
+lean_dec(x_353);
+lean_dec(x_2);
+if (lean_is_exclusive(x_371)) {
+ lean_ctor_release(x_371, 0);
+ lean_ctor_release(x_371, 1);
+ x_406 = x_371;
+} else {
+ lean_dec_ref(x_371);
+ x_406 = lean_box(0);
+}
+if (lean_is_scalar(x_406)) {
+ x_407 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_407 = x_406;
+}
+lean_ctor_set(x_407, 0, x_7);
+lean_ctor_set(x_407, 1, x_354);
+lean_ctor_set_usize(x_407, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_408 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_408 = x_350;
+}
+lean_ctor_set(x_408, 0, x_407);
+lean_ctor_set(x_408, 1, x_348);
+lean_ctor_set_uint64(x_408, sizeof(void*)*2, x_349);
+x_409 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_409, 0, x_408);
+lean_ctor_set(x_409, 1, x_346);
+lean_ctor_set_uint64(x_409, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_410 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_410 = x_357;
+}
+lean_ctor_set(x_410, 0, x_409);
+lean_ctor_set(x_410, 1, x_8);
+lean_ctor_set_uint64(x_410, sizeof(void*)*2, x_345);
+x_411 = lean_apply_1(x_3, x_410);
+return x_411;
+}
+default: 
+{
+lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; lean_object* x_417; 
+lean_dec(x_364);
+lean_dec(x_358);
+lean_dec(x_353);
+lean_dec(x_2);
+if (lean_is_exclusive(x_371)) {
+ lean_ctor_release(x_371, 0);
+ lean_ctor_release(x_371, 1);
+ x_412 = x_371;
+} else {
+ lean_dec_ref(x_371);
+ x_412 = lean_box(0);
+}
+if (lean_is_scalar(x_412)) {
+ x_413 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_413 = x_412;
+ lean_ctor_set_tag(x_413, 1);
+}
+lean_ctor_set(x_413, 0, x_7);
+lean_ctor_set(x_413, 1, x_354);
+lean_ctor_set_usize(x_413, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_414 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_414 = x_350;
+}
+lean_ctor_set(x_414, 0, x_413);
+lean_ctor_set(x_414, 1, x_348);
+lean_ctor_set_uint64(x_414, sizeof(void*)*2, x_349);
+x_415 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_415, 0, x_414);
+lean_ctor_set(x_415, 1, x_346);
+lean_ctor_set_uint64(x_415, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_416 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_416 = x_357;
+}
+lean_ctor_set(x_416, 0, x_415);
+lean_ctor_set(x_416, 1, x_8);
+lean_ctor_set_uint64(x_416, sizeof(void*)*2, x_345);
+x_417 = lean_apply_1(x_3, x_416);
+return x_417;
+}
+}
+}
+default: 
+{
+lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; lean_object* x_422; lean_object* x_423; 
+lean_dec(x_358);
+lean_dec(x_353);
+lean_dec(x_2);
+if (lean_is_exclusive(x_364)) {
+ lean_ctor_release(x_364, 0);
+ lean_ctor_release(x_364, 1);
+ x_418 = x_364;
+} else {
+ lean_dec_ref(x_364);
+ x_418 = lean_box(0);
+}
+if (lean_is_scalar(x_418)) {
+ x_419 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_419 = x_418;
+ lean_ctor_set_tag(x_419, 1);
+}
+lean_ctor_set(x_419, 0, x_7);
+lean_ctor_set(x_419, 1, x_354);
+lean_ctor_set_usize(x_419, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_420 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_420 = x_350;
+}
+lean_ctor_set(x_420, 0, x_419);
+lean_ctor_set(x_420, 1, x_348);
+lean_ctor_set_uint64(x_420, sizeof(void*)*2, x_349);
+x_421 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_421, 0, x_420);
+lean_ctor_set(x_421, 1, x_346);
+lean_ctor_set_uint64(x_421, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_422 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_422 = x_357;
+}
+lean_ctor_set(x_422, 0, x_421);
+lean_ctor_set(x_422, 1, x_8);
+lean_ctor_set_uint64(x_422, sizeof(void*)*2, x_345);
+x_423 = lean_apply_1(x_3, x_422);
+return x_423;
+}
+}
+}
+default: 
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; 
+lean_dec(x_353);
+lean_dec(x_2);
+if (lean_is_exclusive(x_358)) {
+ lean_ctor_release(x_358, 0);
+ lean_ctor_release(x_358, 1);
+ x_424 = x_358;
+} else {
+ lean_dec_ref(x_358);
+ x_424 = lean_box(0);
+}
+if (lean_is_scalar(x_424)) {
+ x_425 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_425 = x_424;
+ lean_ctor_set_tag(x_425, 1);
+}
+lean_ctor_set(x_425, 0, x_7);
+lean_ctor_set(x_425, 1, x_354);
+lean_ctor_set_usize(x_425, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_426 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_426 = x_350;
+}
+lean_ctor_set(x_426, 0, x_425);
+lean_ctor_set(x_426, 1, x_348);
+lean_ctor_set_uint64(x_426, sizeof(void*)*2, x_349);
+x_427 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_427, 0, x_426);
+lean_ctor_set(x_427, 1, x_346);
+lean_ctor_set_uint64(x_427, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_428 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_428 = x_357;
+}
+lean_ctor_set(x_428, 0, x_427);
+lean_ctor_set(x_428, 1, x_8);
+lean_ctor_set_uint64(x_428, sizeof(void*)*2, x_345);
+x_429 = lean_apply_1(x_3, x_428);
+return x_429;
+}
+}
+}
+else
+{
+lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; 
+lean_dec(x_2);
+if (lean_is_scalar(x_353)) {
+ x_430 = lean_alloc_ctor(1, 2, sizeof(size_t)*1);
+} else {
+ x_430 = x_353;
+}
+lean_ctor_set(x_430, 0, x_7);
+lean_ctor_set(x_430, 1, x_354);
+lean_ctor_set_usize(x_430, 2, x_352);
+if (lean_is_scalar(x_350)) {
+ x_431 = lean_alloc_ctor(4, 2, 8);
+} else {
+ x_431 = x_350;
+}
+lean_ctor_set(x_431, 0, x_430);
+lean_ctor_set(x_431, 1, x_348);
+lean_ctor_set_uint64(x_431, sizeof(void*)*2, x_349);
+x_432 = lean_alloc_ctor(5, 2, 8);
+lean_ctor_set(x_432, 0, x_431);
+lean_ctor_set(x_432, 1, x_346);
+lean_ctor_set_uint64(x_432, sizeof(void*)*2, x_347);
+if (lean_is_scalar(x_357)) {
+ x_433 = lean_alloc_ctor(5, 2, 8);
+} else {
+ x_433 = x_357;
+}
+lean_ctor_set(x_433, 0, x_432);
+lean_ctor_set(x_433, 1, x_8);
+lean_ctor_set_uint64(x_433, sizeof(void*)*2, x_345);
+x_434 = lean_apply_1(x_3, x_433);
+return x_434;
+}
+}
+}
+}
+else
+{
+lean_object* x_435; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_435 = lean_apply_1(x_3, x_1);
+return x_435;
+}
+}
+else
+{
+lean_object* x_436; 
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_436 = lean_apply_1(x_3, x_1);
+return x_436;
+}
+}
+else
+{
+lean_object* x_437; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_437 = lean_apply_1(x_3, x_1);
+return x_437;
+}
+}
+else
+{
+lean_object* x_438; 
+lean_dec(x_4);
+lean_dec(x_2);
+x_438 = lean_apply_1(x_3, x_1);
+return x_438;
+}
+}
+else
+{
+lean_object* x_439; 
+lean_dec(x_2);
+x_439 = lean_apply_1(x_3, x_1);
+return x_439;
+}
+}
+}
+lean_object* l_Lean_Expr_isSyntheticSorry_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_isSyntheticSorry_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Expr_isSyntheticSorry(lean_object* x_1) {
 _start:
 {
@@ -163,7 +2805,7 @@ if (lean_obj_tag(x_5) == 0)
 lean_object* x_6; lean_object* x_7; lean_object* x_8; uint8_t x_9; 
 x_6 = lean_ctor_get(x_1, 1);
 x_7 = lean_ctor_get(x_4, 1);
-x_8 = l_Lean_Expr_isSorry___closed__1;
+x_8 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
 x_9 = lean_string_dec_eq(x_7, x_8);
 if (x_9 == 0)
 {
@@ -190,7 +2832,7 @@ if (lean_obj_tag(x_13) == 0)
 lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; 
 x_14 = lean_ctor_get(x_11, 1);
 x_15 = lean_ctor_get(x_12, 1);
-x_16 = l_Lean_Expr_isSyntheticSorry___closed__1;
+x_16 = l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1;
 x_17 = lean_string_dec_eq(x_15, x_16);
 if (x_17 == 0)
 {
@@ -281,17 +2923,195 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-static lean_object* _init_l_Lean_Expr_hasSorry___main___closed__1() {
+lean_object* l_Lean_Expr_hasSorry_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 4:
+{
+lean_object* x_10; lean_object* x_11; uint64_t x_12; lean_object* x_13; lean_object* x_14; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_1, 1);
+lean_inc(x_11);
+x_12 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_13 = lean_box_uint64(x_12);
+x_14 = lean_apply_3(x_2, x_10, x_11, x_13);
+return x_14;
+}
+case 5:
+{
+lean_object* x_15; lean_object* x_16; uint64_t x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_15 = lean_ctor_get(x_1, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 1);
+lean_inc(x_16);
+x_17 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_18 = lean_box_uint64(x_17);
+x_19 = lean_apply_3(x_3, x_15, x_16, x_18);
+return x_19;
+}
+case 6:
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; uint64_t x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_20 = lean_ctor_get(x_1, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_1, 1);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_1, 2);
+lean_inc(x_22);
+x_23 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_24 = lean_box_uint64(x_23);
+x_25 = lean_apply_4(x_6, x_20, x_21, x_22, x_24);
+return x_25;
+}
+case 7:
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; uint64_t x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_26 = lean_ctor_get(x_1, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_1, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_1, 2);
+lean_inc(x_28);
+x_29 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_30 = lean_box_uint64(x_29);
+x_31 = lean_apply_4(x_5, x_26, x_27, x_28, x_30);
+return x_31;
+}
+case 8:
+{
+lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint64_t x_36; lean_object* x_37; lean_object* x_38; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_32 = lean_ctor_get(x_1, 0);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_1, 1);
+lean_inc(x_33);
+x_34 = lean_ctor_get(x_1, 2);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_1, 3);
+lean_inc(x_35);
+x_36 = lean_ctor_get_uint64(x_1, sizeof(void*)*4);
+lean_dec(x_1);
+x_37 = lean_box_uint64(x_36);
+x_38 = lean_apply_5(x_4, x_32, x_33, x_34, x_35, x_37);
+return x_38;
+}
+case 10:
+{
+lean_object* x_39; lean_object* x_40; uint64_t x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_39 = lean_ctor_get(x_1, 0);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_1, 1);
+lean_inc(x_40);
+x_41 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_42 = lean_box_uint64(x_41);
+x_43 = lean_apply_3(x_7, x_39, x_40, x_42);
+return x_43;
+}
+case 11:
+{
+lean_object* x_44; lean_object* x_45; lean_object* x_46; uint64_t x_47; lean_object* x_48; lean_object* x_49; 
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_44 = lean_ctor_get(x_1, 0);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_1, 1);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_1, 2);
+lean_inc(x_46);
+x_47 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_48 = lean_box_uint64(x_47);
+x_49 = lean_apply_4(x_8, x_44, x_45, x_46, x_48);
+return x_49;
+}
+default: 
+{
+lean_object* x_50; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_50 = lean_apply_1(x_9, x_1);
+return x_50;
+}
+}
+}
+}
+lean_object* l_Lean_Expr_hasSorry_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_hasSorry_match__1___rarg), 9, 0);
+return x_2;
+}
+}
+static lean_object* _init_l_Lean_Expr_hasSorry___closed__1() {
 _start:
 {
 lean_object* x_1; lean_object* x_2; lean_object* x_3; 
 x_1 = lean_box(0);
-x_2 = l_Lean_Expr_isSorry___closed__1;
+x_2 = l_Lean_Expr_isSorry_match__1___rarg___closed__1;
 x_3 = lean_name_mk_string(x_1, x_2);
 return x_3;
 }
 }
-uint8_t l_Lean_Expr_hasSorry___main(lean_object* x_1) {
+uint8_t l_Lean_Expr_hasSorry(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -299,7 +3119,7 @@ case 4:
 {
 lean_object* x_2; lean_object* x_3; uint8_t x_4; 
 x_2 = lean_ctor_get(x_1, 0);
-x_3 = l_Lean_Expr_hasSorry___main___closed__1;
+x_3 = l_Lean_Expr_hasSorry___closed__1;
 x_4 = lean_name_eq(x_2, x_3);
 return x_4;
 }
@@ -308,7 +3128,7 @@ case 5:
 lean_object* x_5; lean_object* x_6; uint8_t x_7; 
 x_5 = lean_ctor_get(x_1, 0);
 x_6 = lean_ctor_get(x_1, 1);
-x_7 = l_Lean_Expr_hasSorry___main(x_5);
+x_7 = l_Lean_Expr_hasSorry(x_5);
 if (x_7 == 0)
 {
 x_1 = x_6;
@@ -326,7 +3146,7 @@ case 6:
 lean_object* x_10; lean_object* x_11; uint8_t x_12; 
 x_10 = lean_ctor_get(x_1, 1);
 x_11 = lean_ctor_get(x_1, 2);
-x_12 = l_Lean_Expr_hasSorry___main(x_10);
+x_12 = l_Lean_Expr_hasSorry(x_10);
 if (x_12 == 0)
 {
 x_1 = x_11;
@@ -344,7 +3164,7 @@ case 7:
 lean_object* x_15; lean_object* x_16; uint8_t x_17; 
 x_15 = lean_ctor_get(x_1, 1);
 x_16 = lean_ctor_get(x_1, 2);
-x_17 = l_Lean_Expr_hasSorry___main(x_15);
+x_17 = l_Lean_Expr_hasSorry(x_15);
 if (x_17 == 0)
 {
 x_1 = x_16;
@@ -363,11 +3183,11 @@ lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23;
 x_20 = lean_ctor_get(x_1, 1);
 x_21 = lean_ctor_get(x_1, 2);
 x_22 = lean_ctor_get(x_1, 3);
-x_23 = l_Lean_Expr_hasSorry___main(x_20);
+x_23 = l_Lean_Expr_hasSorry(x_20);
 if (x_23 == 0)
 {
 uint8_t x_24; 
-x_24 = l_Lean_Expr_hasSorry___main(x_21);
+x_24 = l_Lean_Expr_hasSorry(x_21);
 if (x_24 == 0)
 {
 x_1 = x_22;
@@ -410,24 +3230,6 @@ return x_32;
 }
 }
 }
-lean_object* l_Lean_Expr_hasSorry___main___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_Expr_hasSorry___main(x_1);
-lean_dec(x_1);
-x_3 = lean_box(x_2);
-return x_3;
-}
-}
-uint8_t l_Lean_Expr_hasSorry(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; 
-x_2 = l_Lean_Expr_hasSorry___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_Expr_hasSorry___boxed(lean_object* x_1) {
 _start:
 {
@@ -438,7 +3240,157 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-uint8_t l_Lean_Expr_hasSyntheticSorry___main(lean_object* x_1) {
+lean_object* l_Lean_Expr_hasSyntheticSorry_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 5:
+{
+lean_object* x_9; lean_object* x_10; uint64_t x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+x_12 = lean_box_uint64(x_11);
+x_13 = lean_apply_4(x_2, x_1, x_9, x_10, x_12);
+return x_13;
+}
+case 6:
+{
+lean_object* x_14; lean_object* x_15; lean_object* x_16; uint64_t x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_1, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 2);
+lean_inc(x_16);
+x_17 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_18 = lean_box_uint64(x_17);
+x_19 = lean_apply_4(x_5, x_14, x_15, x_16, x_18);
+return x_19;
+}
+case 7:
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; uint64_t x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_20 = lean_ctor_get(x_1, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_1, 1);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_1, 2);
+lean_inc(x_22);
+x_23 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_24 = lean_box_uint64(x_23);
+x_25 = lean_apply_4(x_4, x_20, x_21, x_22, x_24);
+return x_25;
+}
+case 8:
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint64_t x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_26 = lean_ctor_get(x_1, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_1, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_1, 2);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_1, 3);
+lean_inc(x_29);
+x_30 = lean_ctor_get_uint64(x_1, sizeof(void*)*4);
+lean_dec(x_1);
+x_31 = lean_box_uint64(x_30);
+x_32 = lean_apply_5(x_3, x_26, x_27, x_28, x_29, x_31);
+return x_32;
+}
+case 10:
+{
+lean_object* x_33; lean_object* x_34; uint64_t x_35; lean_object* x_36; lean_object* x_37; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_33 = lean_ctor_get(x_1, 0);
+lean_inc(x_33);
+x_34 = lean_ctor_get(x_1, 1);
+lean_inc(x_34);
+x_35 = lean_ctor_get_uint64(x_1, sizeof(void*)*2);
+lean_dec(x_1);
+x_36 = lean_box_uint64(x_35);
+x_37 = lean_apply_3(x_6, x_33, x_34, x_36);
+return x_37;
+}
+case 11:
+{
+lean_object* x_38; lean_object* x_39; lean_object* x_40; uint64_t x_41; lean_object* x_42; lean_object* x_43; 
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_38 = lean_ctor_get(x_1, 0);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_1, 1);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_1, 2);
+lean_inc(x_40);
+x_41 = lean_ctor_get_uint64(x_1, sizeof(void*)*3);
+lean_dec(x_1);
+x_42 = lean_box_uint64(x_41);
+x_43 = lean_apply_4(x_7, x_38, x_39, x_40, x_42);
+return x_43;
+}
+default: 
+{
+lean_object* x_44; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_44 = lean_apply_1(x_8, x_1);
+return x_44;
+}
+}
+}
+}
+lean_object* l_Lean_Expr_hasSyntheticSorry_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Expr_hasSyntheticSorry_match__1___rarg), 8, 0);
+return x_2;
+}
+}
+uint8_t l_Lean_Expr_hasSyntheticSorry(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -451,7 +3403,7 @@ x_4 = l_Lean_Expr_isSyntheticSorry(x_1);
 if (x_4 == 0)
 {
 uint8_t x_5; 
-x_5 = l_Lean_Expr_hasSyntheticSorry___main(x_2);
+x_5 = l_Lean_Expr_hasSyntheticSorry(x_2);
 if (x_5 == 0)
 {
 x_1 = x_3;
@@ -476,7 +3428,7 @@ case 6:
 lean_object* x_9; lean_object* x_10; uint8_t x_11; 
 x_9 = lean_ctor_get(x_1, 1);
 x_10 = lean_ctor_get(x_1, 2);
-x_11 = l_Lean_Expr_hasSyntheticSorry___main(x_9);
+x_11 = l_Lean_Expr_hasSyntheticSorry(x_9);
 if (x_11 == 0)
 {
 x_1 = x_10;
@@ -494,7 +3446,7 @@ case 7:
 lean_object* x_14; lean_object* x_15; uint8_t x_16; 
 x_14 = lean_ctor_get(x_1, 1);
 x_15 = lean_ctor_get(x_1, 2);
-x_16 = l_Lean_Expr_hasSyntheticSorry___main(x_14);
+x_16 = l_Lean_Expr_hasSyntheticSorry(x_14);
 if (x_16 == 0)
 {
 x_1 = x_15;
@@ -513,11 +3465,11 @@ lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22;
 x_19 = lean_ctor_get(x_1, 1);
 x_20 = lean_ctor_get(x_1, 2);
 x_21 = lean_ctor_get(x_1, 3);
-x_22 = l_Lean_Expr_hasSyntheticSorry___main(x_19);
+x_22 = l_Lean_Expr_hasSyntheticSorry(x_19);
 if (x_22 == 0)
 {
 uint8_t x_23; 
-x_23 = l_Lean_Expr_hasSyntheticSorry___main(x_20);
+x_23 = l_Lean_Expr_hasSyntheticSorry(x_20);
 if (x_23 == 0)
 {
 x_1 = x_21;
@@ -560,24 +3512,6 @@ return x_31;
 }
 }
 }
-lean_object* l_Lean_Expr_hasSyntheticSorry___main___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_Expr_hasSyntheticSorry___main(x_1);
-lean_dec(x_1);
-x_3 = lean_box(x_2);
-return x_3;
-}
-}
-uint8_t l_Lean_Expr_hasSyntheticSorry(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; 
-x_2 = l_Lean_Expr_hasSyntheticSorry___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_Expr_hasSyntheticSorry___boxed(lean_object* x_1) {
 _start:
 {
@@ -588,7 +3522,155 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_MessageData_hasSorry_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 2:
+{
+lean_object* x_10; lean_object* x_11; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_apply_1(x_2, x_10);
+return x_11;
+}
+case 6:
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+lean_dec(x_1);
+x_14 = lean_apply_2(x_3, x_12, x_13);
+return x_14;
+}
+case 8:
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_15 = lean_ctor_get(x_1, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 1);
+lean_inc(x_16);
+lean_dec(x_1);
+x_17 = lean_apply_2(x_4, x_15, x_16);
+return x_17;
+}
+case 9:
+{
+lean_object* x_18; lean_object* x_19; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_18 = lean_ctor_get(x_1, 0);
+lean_inc(x_18);
+lean_dec(x_1);
+x_19 = lean_apply_1(x_5, x_18);
+return x_19;
+}
+case 10:
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_20 = lean_ctor_get(x_1, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_1, 1);
+lean_inc(x_21);
+lean_dec(x_1);
+x_22 = lean_apply_2(x_6, x_20, x_21);
+return x_22;
+}
+case 11:
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_23 = lean_ctor_get(x_1, 0);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_1, 1);
+lean_inc(x_24);
+lean_dec(x_1);
+x_25 = lean_apply_2(x_7, x_23, x_24);
+return x_25;
+}
+case 12:
+{
+lean_object* x_26; lean_object* x_27; 
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_26 = lean_ctor_get(x_1, 0);
+lean_inc(x_26);
+lean_dec(x_1);
+x_27 = lean_apply_1(x_8, x_26);
+return x_27;
+}
+default: 
+{
+lean_object* x_28; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_28 = lean_apply_1(x_9, x_1);
+return x_28;
+}
+}
+}
+}
+lean_object* l_Lean_MessageData_hasSorry_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_MessageData_hasSorry_match__1___rarg), 9, 0);
+return x_2;
+}
+}
+uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -604,7 +3686,7 @@ else
 {
 lean_object* x_7; uint8_t x_8; 
 x_7 = lean_array_fget(x_2, x_4);
-x_8 = l_Lean_MessageData_hasSorry___main(x_7);
+x_8 = l_Lean_MessageData_hasSorry(x_7);
 lean_dec(x_7);
 if (x_8 == 0)
 {
@@ -623,7 +3705,7 @@ return x_8;
 }
 }
 }
-uint8_t l_Lean_MessageData_hasSorry___main(lean_object* x_1) {
+uint8_t l_Lean_MessageData_hasSorry(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -631,7 +3713,7 @@ case 2:
 {
 lean_object* x_2; uint8_t x_3; 
 x_2 = lean_ctor_get(x_1, 0);
-x_3 = l_Lean_Expr_hasSorry___main(x_2);
+x_3 = l_Lean_Expr_hasSorry(x_2);
 return x_3;
 }
 case 6:
@@ -660,7 +3742,7 @@ case 10:
 lean_object* x_10; lean_object* x_11; uint8_t x_12; 
 x_10 = lean_ctor_get(x_1, 0);
 x_11 = lean_ctor_get(x_1, 1);
-x_12 = l_Lean_MessageData_hasSorry___main(x_10);
+x_12 = l_Lean_MessageData_hasSorry(x_10);
 if (x_12 == 0)
 {
 x_1 = x_11;
@@ -686,7 +3768,7 @@ lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20;
 x_17 = lean_ctor_get(x_1, 0);
 x_18 = lean_array_get_size(x_17);
 x_19 = lean_unsigned_to_nat(0u);
-x_20 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___main___spec__1(x_17, x_17, x_18, x_19);
+x_20 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___spec__1(x_17, x_17, x_18, x_19);
 lean_dec(x_18);
 return x_20;
 }
@@ -699,11 +3781,11 @@ return x_21;
 }
 }
 }
-lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___main___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___spec__1___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 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___main___spec__1(x_1, x_2, x_3, x_4);
+x_5 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSorry___spec__1(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -711,24 +3793,6 @@ x_6 = lean_box(x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_MessageData_hasSorry___main___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_MessageData_hasSorry___main(x_1);
-lean_dec(x_1);
-x_3 = lean_box(x_2);
-return x_3;
-}
-}
-uint8_t l_Lean_MessageData_hasSorry(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; 
-x_2 = l_Lean_MessageData_hasSorry___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_MessageData_hasSorry___boxed(lean_object* x_1) {
 _start:
 {
@@ -739,7 +3803,155 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___main___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Lean_MessageData_hasSyntheticSorry_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9) {
+_start:
+{
+switch (lean_obj_tag(x_1)) {
+case 2:
+{
+lean_object* x_10; lean_object* x_11; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_10 = lean_ctor_get(x_1, 0);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_apply_1(x_2, x_10);
+return x_11;
+}
+case 6:
+{
+lean_object* x_12; lean_object* x_13; lean_object* x_14; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_2);
+x_12 = lean_ctor_get(x_1, 0);
+lean_inc(x_12);
+x_13 = lean_ctor_get(x_1, 1);
+lean_inc(x_13);
+lean_dec(x_1);
+x_14 = lean_apply_2(x_3, x_12, x_13);
+return x_14;
+}
+case 8:
+{
+lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_3);
+lean_dec(x_2);
+x_15 = lean_ctor_get(x_1, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 1);
+lean_inc(x_16);
+lean_dec(x_1);
+x_17 = lean_apply_2(x_4, x_15, x_16);
+return x_17;
+}
+case 9:
+{
+lean_object* x_18; lean_object* x_19; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_18 = lean_ctor_get(x_1, 0);
+lean_inc(x_18);
+lean_dec(x_1);
+x_19 = lean_apply_1(x_5, x_18);
+return x_19;
+}
+case 10:
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_20 = lean_ctor_get(x_1, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_1, 1);
+lean_inc(x_21);
+lean_dec(x_1);
+x_22 = lean_apply_2(x_6, x_20, x_21);
+return x_22;
+}
+case 11:
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; 
+lean_dec(x_9);
+lean_dec(x_8);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_23 = lean_ctor_get(x_1, 0);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_1, 1);
+lean_inc(x_24);
+lean_dec(x_1);
+x_25 = lean_apply_2(x_7, x_23, x_24);
+return x_25;
+}
+case 12:
+{
+lean_object* x_26; lean_object* x_27; 
+lean_dec(x_9);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_26 = lean_ctor_get(x_1, 0);
+lean_inc(x_26);
+lean_dec(x_1);
+x_27 = lean_apply_1(x_8, x_26);
+return x_27;
+}
+default: 
+{
+lean_object* x_28; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+lean_dec(x_2);
+x_28 = lean_apply_1(x_9, x_1);
+return x_28;
+}
+}
+}
+}
+lean_object* l_Lean_MessageData_hasSyntheticSorry_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_MessageData_hasSyntheticSorry_match__1___rarg), 9, 0);
+return x_2;
+}
+}
+uint8_t l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 uint8_t x_5; 
@@ -755,7 +3967,7 @@ else
 {
 lean_object* x_7; uint8_t x_8; 
 x_7 = lean_array_fget(x_2, x_4);
-x_8 = l_Lean_MessageData_hasSyntheticSorry___main(x_7);
+x_8 = l_Lean_MessageData_hasSyntheticSorry(x_7);
 lean_dec(x_7);
 if (x_8 == 0)
 {
@@ -774,7 +3986,7 @@ return x_8;
 }
 }
 }
-uint8_t l_Lean_MessageData_hasSyntheticSorry___main(lean_object* x_1) {
+uint8_t l_Lean_MessageData_hasSyntheticSorry(lean_object* x_1) {
 _start:
 {
 switch (lean_obj_tag(x_1)) {
@@ -782,7 +3994,7 @@ case 2:
 {
 lean_object* x_2; uint8_t x_3; 
 x_2 = lean_ctor_get(x_1, 0);
-x_3 = l_Lean_Expr_hasSyntheticSorry___main(x_2);
+x_3 = l_Lean_Expr_hasSyntheticSorry(x_2);
 return x_3;
 }
 case 6:
@@ -811,7 +4023,7 @@ case 10:
 lean_object* x_10; lean_object* x_11; uint8_t x_12; 
 x_10 = lean_ctor_get(x_1, 0);
 x_11 = lean_ctor_get(x_1, 1);
-x_12 = l_Lean_MessageData_hasSyntheticSorry___main(x_10);
+x_12 = l_Lean_MessageData_hasSyntheticSorry(x_10);
 if (x_12 == 0)
 {
 x_1 = x_11;
@@ -837,7 +4049,7 @@ lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20;
 x_17 = lean_ctor_get(x_1, 0);
 x_18 = lean_array_get_size(x_17);
 x_19 = lean_unsigned_to_nat(0u);
-x_20 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___main___spec__1(x_17, x_17, x_18, x_19);
+x_20 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___spec__1(x_17, x_17, x_18, x_19);
 lean_dec(x_18);
 return x_20;
 }
@@ -850,11 +4062,11 @@ return x_21;
 }
 }
 }
-lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___main___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___spec__1___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 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___main___spec__1(x_1, x_2, x_3, x_4);
+x_5 = l_Array_anyRangeMAux___main___at_Lean_MessageData_hasSyntheticSorry___spec__1(x_1, x_2, x_3, x_4);
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
@@ -862,24 +4074,6 @@ x_6 = lean_box(x_5);
 return x_6;
 }
 }
-lean_object* l_Lean_MessageData_hasSyntheticSorry___main___boxed(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; lean_object* x_3; 
-x_2 = l_Lean_MessageData_hasSyntheticSorry___main(x_1);
-lean_dec(x_1);
-x_3 = lean_box(x_2);
-return x_3;
-}
-}
-uint8_t l_Lean_MessageData_hasSyntheticSorry(lean_object* x_1) {
-_start:
-{
-uint8_t x_2; 
-x_2 = l_Lean_MessageData_hasSyntheticSorry___main(x_1);
-return x_2;
-}
-}
 lean_object* l_Lean_MessageData_hasSyntheticSorry___boxed(lean_object* x_1) {
 _start:
 {
@@ -890,6 +4084,38 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Lean_Exception_hasSyntheticSorry_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; lean_object* x_6; 
+lean_dec(x_3);
+x_4 = lean_ctor_get(x_1, 0);
+lean_inc(x_4);
+x_5 = lean_ctor_get(x_1, 1);
+lean_inc(x_5);
+lean_dec(x_1);
+x_6 = lean_apply_2(x_2, x_4, x_5);
+return x_6;
+}
+else
+{
+lean_object* x_7; 
+lean_dec(x_2);
+x_7 = lean_apply_1(x_3, x_1);
+return x_7;
+}
+}
+}
+lean_object* l_Lean_Exception_hasSyntheticSorry_match__1(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_alloc_closure((void*)(l_Lean_Exception_hasSyntheticSorry_match__1___rarg), 3, 0);
+return x_2;
+}
+}
 uint8_t l_Lean_Exception_hasSyntheticSorry(lean_object* x_1) {
 _start:
 {
@@ -897,7 +4123,7 @@ if (lean_obj_tag(x_1) == 0)
 {
 lean_object* x_2; uint8_t x_3; 
 x_2 = lean_ctor_get(x_1, 1);
-x_3 = l_Lean_MessageData_hasSyntheticSorry___main(x_2);
+x_3 = l_Lean_MessageData_hasSyntheticSorry(x_2);
 return x_3;
 }
 else
@@ -935,12 +4161,12 @@ lean_dec_ref(res);
 res = initialize_Lean_Exception(lean_io_mk_world());
 if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
-l_Lean_Expr_isSorry___closed__1 = _init_l_Lean_Expr_isSorry___closed__1();
-lean_mark_persistent(l_Lean_Expr_isSorry___closed__1);
-l_Lean_Expr_isSyntheticSorry___closed__1 = _init_l_Lean_Expr_isSyntheticSorry___closed__1();
-lean_mark_persistent(l_Lean_Expr_isSyntheticSorry___closed__1);
-l_Lean_Expr_hasSorry___main___closed__1 = _init_l_Lean_Expr_hasSorry___main___closed__1();
-lean_mark_persistent(l_Lean_Expr_hasSorry___main___closed__1);
+l_Lean_Expr_isSorry_match__1___rarg___closed__1 = _init_l_Lean_Expr_isSorry_match__1___rarg___closed__1();
+lean_mark_persistent(l_Lean_Expr_isSorry_match__1___rarg___closed__1);
+l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1 = _init_l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1();
+lean_mark_persistent(l_Lean_Expr_isSyntheticSorry_match__1___rarg___closed__1);
+l_Lean_Expr_hasSorry___closed__1 = _init_l_Lean_Expr_hasSorry___closed__1();
+lean_mark_persistent(l_Lean_Expr_hasSorry___closed__1);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Std/Data/BinomialHeap.c b/stage0/stdlib/Std/Data/BinomialHeap.c
index 5deecc3746..849672dc2d 100644
--- a/stage0/stdlib/Std/Data/BinomialHeap.c
+++ b/stage0/stdlib/Std/Data/BinomialHeap.c
@@ -13,57 +13,90 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Std_BinomialHeapImp_isEmpty_match__1(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_merge___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_hRank___rarg(lean_object*);
-lean_object* l_Std_BinomialHeapImp_toList___main(lean_object*);
-lean_object* l_Std_BinomialHeapImp_findMin___main(lean_object*);
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__1(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_mergeNodes_match__1(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_tail_match__2___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_singleton___boxed(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_head___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_findMin_match__1(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_findMin(lean_object*);
 lean_object* l_Std_BinomialHeapImp_head_x3f(lean_object*);
+lean_object* l_Std_BinomialHeapImp_mergeNodes_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_head_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__2(lean_object*);
-lean_object* l_Std_BinomialHeapImp_findMin___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_isEmpty___rarg___boxed(lean_object*);
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_insert(lean_object*);
+lean_object* l_Std_BinomialHeap_merge_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_tail_match__1(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_toList_match__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_combine___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_head_x3f(lean_object*);
 lean_object* l_Std_BinomialHeapImp_mergeNodes(lean_object*);
 lean_object* l_Std_BinomialHeap_head___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_isEmpty_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_findMin___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_insert___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_BinomialHeapImp_isEmpty___rarg(lean_object*);
 lean_object* l_Std_BinomialHeapImp_singleton(lean_object*);
+lean_object* l_Std_BinomialHeapImp_hRank_match__1(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__2(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_mergeNodes___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_nat_add(lean_object*, lean_object*);
 uint8_t l_Std_BinomialHeap_isEmpty___rarg(lean_object*);
+lean_object* l_Std_BinomialHeapImp_tail_match__2(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_head_x3f___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_toList(lean_object*);
 lean_object* l_Std_BinomialHeapImp_head(lean_object*);
+lean_object* l_Std_BinomialHeap_head_match__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_toList___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_isEmpty(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_empty___boxed(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_isEmpty_match__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t lean_nat_dec_eq(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_tail_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_head___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_head_x3f_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_head_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_merge___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_head(lean_object*);
 lean_object* l_Std_BinomialHeapImp_toList(lean_object*);
-lean_object* l_Std_BinomialHeapImp_toList___main___rarg(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_tail_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__1(lean_object*);
+lean_object* l_Std_BinomialHeapImp_merge_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_Std_Data_BinomialHeap___instance__1(lean_object*);
+lean_object* l_Std_BinomialHeapImp_findMin_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_singleton(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_toList_match__1(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_isEmpty_match__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_isEmpty(lean_object*);
 lean_object* l_Std_mkBinomialHeap___boxed(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_tail_match__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_head___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_toList_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_eraseIdx___main___rarg(lean_object*, lean_object*);
-lean_object* l_Std_BinomialHeapImp_mergeNodes___main(lean_object*);
+lean_object* l_Std_BinomialHeap_tail_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_isEmpty_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_tail_match__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_head_match__1(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_head_x3f_match__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_toList_match__2(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_merge_match__1(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_head_x3f___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_merge_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_toList___rarg(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_toList_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_hRank(lean_object*);
 lean_object* l_Std_BinomialHeapImp_merge(lean_object*);
 lean_object* l_Std_BinomialHeapImp_head___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_BinomialHeapImp_Inhabited(lean_object*);
+lean_object* l_Std_BinomialHeapImp_toList_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_tail(lean_object*);
 lean_object* l_Std_BinomialHeap_tail___rarg(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_hRank___rarg___boxed(lean_object*);
@@ -73,15 +106,20 @@ lean_object* l_Std_BinomialHeap_isEmpty___boxed(lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_isEmpty___rarg___boxed(lean_object*);
 lean_object* l_Std_BinomialHeap_merge(lean_object*);
 lean_object* l_Std_BinomialHeap_empty(lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_merge_match__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_combine(lean_object*);
 lean_object* l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_tail___rarg(lean_object*, lean_object*);
-lean_object* l_Std_BinomialHeapImp_mergeNodes___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_head_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeapImp_singleton___rarg(lean_object*);
 lean_object* l_Std_BinomialHeap_singleton___rarg(lean_object*);
+lean_object* l_Std_BinomialHeapImp_toList_match__2___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeap_head_x3f_match__1___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_BinomialHeapImp_hRank_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_BinomialHeap_tail(lean_object*);
+lean_object* l_Std_BinomialHeapImp_tail_match__3(lean_object*, lean_object*);
 uint8_t lean_nat_dec_lt(lean_object*, lean_object*);
-lean_object* l_Std_BinomialHeapImp_Inhabited(lean_object* x_1) {
+lean_object* l_Std_BinomialHeapImp_Std_Data_BinomialHeap___instance__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
@@ -89,6 +127,39 @@ x_2 = lean_box(0);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeapImp_hRank_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_2(x_3, x_6, x_7);
+return x_8;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_hRank_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_hRank_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 lean_object* l_Std_BinomialHeapImp_hRank___rarg(lean_object* x_1) {
 _start:
 {
@@ -125,6 +196,34 @@ lean_dec(x_1);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeapImp_isEmpty_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; 
+lean_dec(x_2);
+x_6 = lean_apply_1(x_3, x_1);
+return x_6;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_isEmpty_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_isEmpty_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 uint8_t l_Std_BinomialHeapImp_isEmpty___rarg(lean_object* x_1) {
 _start:
 {
@@ -331,7 +430,54 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_combine___rarg), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_BinomialHeapImp_mergeNodes___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_BinomialHeapImp_mergeNodes_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_6; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_6 = lean_apply_1(x_3, x_2);
+return x_6;
+}
+else
+{
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_7; 
+lean_dec(x_5);
+x_7 = lean_apply_1(x_4, x_1);
+return x_7;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 1);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_2, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_2, 1);
+lean_inc(x_11);
+x_12 = lean_apply_6(x_5, x_1, x_8, x_9, x_2, x_10, x_11);
+return x_12;
+}
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_mergeNodes_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_mergeNodes_match__1___rarg), 5, 0);
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeapImp_mergeNodes___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -364,224 +510,169 @@ lean_inc(x_9);
 x_10 = lean_nat_dec_lt(x_8, x_9);
 if (x_10 == 0)
 {
-uint8_t x_11; 
-x_11 = !lean_is_exclusive(x_3);
-if (x_11 == 0)
-{
-lean_object* x_12; lean_object* x_13; uint8_t x_14; 
-x_12 = lean_ctor_get(x_3, 1);
-lean_dec(x_12);
-x_13 = lean_ctor_get(x_3, 0);
-lean_dec(x_13);
-x_14 = lean_nat_dec_lt(x_9, x_8);
+lean_object* x_11; uint8_t x_12; 
+if (lean_is_exclusive(x_3)) {
+ lean_ctor_release(x_3, 0);
+ lean_ctor_release(x_3, 1);
+ x_11 = x_3;
+} else {
+ lean_dec_ref(x_3);
+ x_11 = lean_box(0);
+}
+x_12 = lean_nat_dec_lt(x_9, x_8);
 lean_dec(x_8);
 lean_dec(x_9);
-if (x_14 == 0)
+if (x_12 == 0)
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_29; uint8_t x_30; 
 lean_dec(x_2);
 lean_inc(x_1);
-x_15 = l_Std_BinomialHeapImp_combine___rarg(x_1, x_4, x_6);
-x_16 = lean_ctor_get(x_15, 1);
-lean_inc(x_16);
-x_17 = l_Std_BinomialHeapImp_hRank___rarg(x_5);
-x_18 = lean_nat_dec_eq(x_16, x_17);
-lean_dec(x_17);
-if (x_18 == 0)
+x_13 = l_Std_BinomialHeapImp_combine___rarg(x_1, x_4, x_6);
+x_14 = lean_ctor_get(x_13, 1);
+lean_inc(x_14);
+x_29 = l_Std_BinomialHeapImp_hRank___rarg(x_5);
+x_30 = lean_nat_dec_eq(x_14, x_29);
+lean_dec(x_29);
+if (x_30 == 0)
 {
-lean_object* x_19; uint8_t x_20; 
-x_19 = l_Std_BinomialHeapImp_hRank___rarg(x_7);
-x_20 = lean_nat_dec_eq(x_16, x_19);
-lean_dec(x_19);
-lean_dec(x_16);
-if (x_20 == 0)
-{
-lean_object* x_21; 
-x_21 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_5, x_7);
-lean_ctor_set(x_3, 1, x_21);
-lean_ctor_set(x_3, 0, x_15);
-return x_3;
+uint8_t x_31; 
+x_31 = 1;
+x_15 = x_31;
+goto block_28;
 }
 else
 {
-lean_ctor_set(x_3, 1, x_5);
-lean_ctor_set(x_3, 0, x_15);
-x_2 = x_3;
-x_3 = x_7;
-goto _start;
+uint8_t x_32; 
+x_32 = 0;
+x_15 = x_32;
+goto block_28;
 }
-}
-else
+block_28:
 {
-lean_object* x_23; uint8_t x_24; 
-x_23 = l_Std_BinomialHeapImp_hRank___rarg(x_7);
-x_24 = lean_nat_dec_eq(x_16, x_23);
-lean_dec(x_23);
+if (x_15 == 0)
+{
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_BinomialHeapImp_hRank___rarg(x_7);
+x_17 = lean_nat_dec_eq(x_14, x_16);
 lean_dec(x_16);
-if (x_24 == 0)
+lean_dec(x_14);
+if (x_17 == 0)
 {
-lean_ctor_set(x_3, 0, x_15);
+lean_object* x_18; 
+if (lean_is_scalar(x_11)) {
+ x_18 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_18 = x_11;
+}
+lean_ctor_set(x_18, 0, x_13);
+lean_ctor_set(x_18, 1, x_7);
 x_2 = x_5;
+x_3 = x_18;
 goto _start;
 }
 else
 {
+lean_object* x_20; lean_object* x_21; 
+x_20 = l_Std_BinomialHeapImp_mergeNodes___rarg(x_1, x_5, x_7);
+if (lean_is_scalar(x_11)) {
+ x_21 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_21 = x_11;
+}
+lean_ctor_set(x_21, 0, x_13);
+lean_ctor_set(x_21, 1, x_20);
+return x_21;
+}
+}
+else
+{
+lean_object* x_22; uint8_t x_23; 
+x_22 = l_Std_BinomialHeapImp_hRank___rarg(x_7);
+x_23 = lean_nat_dec_eq(x_14, x_22);
+lean_dec(x_22);
+lean_dec(x_14);
+if (x_23 == 0)
+{
+lean_object* x_24; lean_object* x_25; 
+x_24 = l_Std_BinomialHeapImp_mergeNodes___rarg(x_1, x_5, x_7);
+if (lean_is_scalar(x_11)) {
+ x_25 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_25 = x_11;
+}
+lean_ctor_set(x_25, 0, x_13);
+lean_ctor_set(x_25, 1, x_24);
+return x_25;
+}
+else
+{
 lean_object* x_26; 
-x_26 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_5, x_7);
-lean_ctor_set(x_3, 1, x_26);
-lean_ctor_set(x_3, 0, x_15);
-return x_3;
+if (lean_is_scalar(x_11)) {
+ x_26 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_26 = x_11;
 }
-}
-}
-else
-{
-lean_object* x_27; 
-lean_dec(x_5);
-lean_dec(x_4);
-x_27 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_7, x_2);
-lean_ctor_set(x_3, 1, x_27);
-return x_3;
-}
-}
-else
-{
-uint8_t x_28; 
-lean_dec(x_3);
-x_28 = lean_nat_dec_lt(x_9, x_8);
-lean_dec(x_8);
-lean_dec(x_9);
-if (x_28 == 0)
-{
-lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; 
-lean_dec(x_2);
-lean_inc(x_1);
-x_29 = l_Std_BinomialHeapImp_combine___rarg(x_1, x_4, x_6);
-x_30 = lean_ctor_get(x_29, 1);
-lean_inc(x_30);
-x_31 = l_Std_BinomialHeapImp_hRank___rarg(x_5);
-x_32 = lean_nat_dec_eq(x_30, x_31);
-lean_dec(x_31);
-if (x_32 == 0)
-{
-lean_object* x_33; uint8_t x_34; 
-x_33 = l_Std_BinomialHeapImp_hRank___rarg(x_7);
-x_34 = lean_nat_dec_eq(x_30, x_33);
-lean_dec(x_33);
-lean_dec(x_30);
-if (x_34 == 0)
-{
-lean_object* x_35; lean_object* x_36; 
-x_35 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_5, x_7);
-x_36 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_36, 0, x_29);
-lean_ctor_set(x_36, 1, x_35);
-return x_36;
-}
-else
-{
-lean_object* x_37; 
-x_37 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_37, 0, x_29);
-lean_ctor_set(x_37, 1, x_5);
-x_2 = x_37;
+lean_ctor_set(x_26, 0, x_13);
+lean_ctor_set(x_26, 1, x_5);
+x_2 = x_26;
 x_3 = x_7;
 goto _start;
 }
 }
-else
-{
-lean_object* x_39; uint8_t x_40; 
-x_39 = l_Std_BinomialHeapImp_hRank___rarg(x_7);
-x_40 = lean_nat_dec_eq(x_30, x_39);
-lean_dec(x_39);
-lean_dec(x_30);
-if (x_40 == 0)
-{
-lean_object* x_41; 
-x_41 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_41, 0, x_29);
-lean_ctor_set(x_41, 1, x_7);
-x_2 = x_5;
-x_3 = x_41;
-goto _start;
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-x_43 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_5, x_7);
-x_44 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_44, 0, x_29);
-lean_ctor_set(x_44, 1, x_43);
-return x_44;
-}
 }
 }
 else
 {
-lean_object* x_45; lean_object* x_46; 
+lean_object* x_33; lean_object* x_34; 
 lean_dec(x_5);
 lean_dec(x_4);
-x_45 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_7, x_2);
-x_46 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_46, 0, x_6);
-lean_ctor_set(x_46, 1, x_45);
-return x_46;
+x_33 = l_Std_BinomialHeapImp_mergeNodes___rarg(x_1, x_7, x_2);
+if (lean_is_scalar(x_11)) {
+ x_34 = lean_alloc_ctor(1, 2, 0);
+} else {
+ x_34 = x_11;
 }
+lean_ctor_set(x_34, 0, x_6);
+lean_ctor_set(x_34, 1, x_33);
+return x_34;
 }
 }
 else
 {
-lean_object* x_47; uint8_t x_48; 
+lean_object* x_35; uint8_t x_36; 
 lean_dec(x_9);
 lean_dec(x_8);
 lean_dec(x_7);
 lean_dec(x_6);
 lean_dec(x_2);
 lean_inc(x_3);
-x_47 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_5, x_3);
-x_48 = !lean_is_exclusive(x_3);
-if (x_48 == 0)
+x_35 = l_Std_BinomialHeapImp_mergeNodes___rarg(x_1, x_5, x_3);
+x_36 = !lean_is_exclusive(x_3);
+if (x_36 == 0)
 {
-lean_object* x_49; lean_object* x_50; 
-x_49 = lean_ctor_get(x_3, 1);
-lean_dec(x_49);
-x_50 = lean_ctor_get(x_3, 0);
-lean_dec(x_50);
-lean_ctor_set(x_3, 1, x_47);
+lean_object* x_37; lean_object* x_38; 
+x_37 = lean_ctor_get(x_3, 1);
+lean_dec(x_37);
+x_38 = lean_ctor_get(x_3, 0);
+lean_dec(x_38);
+lean_ctor_set(x_3, 1, x_35);
 lean_ctor_set(x_3, 0, x_4);
 return x_3;
 }
 else
 {
-lean_object* x_51; 
+lean_object* x_39; 
 lean_dec(x_3);
-x_51 = lean_alloc_ctor(1, 2, 0);
-lean_ctor_set(x_51, 0, x_4);
-lean_ctor_set(x_51, 1, x_47);
-return x_51;
+x_39 = lean_alloc_ctor(1, 2, 0);
+lean_ctor_set(x_39, 0, x_4);
+lean_ctor_set(x_39, 1, x_35);
+return x_39;
 }
 }
 }
 }
 }
 }
-lean_object* l_Std_BinomialHeapImp_mergeNodes___main(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_mergeNodes___main___rarg), 3, 0);
-return x_2;
-}
-}
-lean_object* l_Std_BinomialHeapImp_mergeNodes___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_2, x_3);
-return x_4;
-}
-}
 lean_object* l_Std_BinomialHeapImp_mergeNodes(lean_object* x_1) {
 _start:
 {
@@ -590,6 +681,51 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_mergeNodes___rarg), 3, 0)
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeapImp_merge_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_6; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_6 = lean_apply_1(x_3, x_2);
+return x_6;
+}
+else
+{
+lean_dec(x_3);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_7; 
+lean_dec(x_5);
+x_7 = lean_apply_1(x_4, x_1);
+return x_7;
+}
+else
+{
+lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_4);
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+lean_dec(x_1);
+x_9 = lean_ctor_get(x_2, 0);
+lean_inc(x_9);
+lean_dec(x_2);
+x_10 = lean_apply_2(x_5, x_8, x_9);
+return x_10;
+}
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_merge_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_merge_match__1___rarg), 5, 0);
+return x_3;
+}
+}
 lean_object* l_Std_BinomialHeapImp_merge___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -616,7 +752,7 @@ if (x_5 == 0)
 {
 lean_object* x_6; lean_object* x_7; 
 x_6 = lean_ctor_get(x_3, 0);
-x_7 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_4, x_6);
+x_7 = l_Std_BinomialHeapImp_mergeNodes___rarg(x_1, x_4, x_6);
 lean_ctor_set(x_3, 0, x_7);
 return x_3;
 }
@@ -626,7 +762,7 @@ lean_object* x_8; lean_object* x_9; lean_object* x_10;
 x_8 = lean_ctor_get(x_3, 0);
 lean_inc(x_8);
 lean_dec(x_3);
-x_9 = l_Std_BinomialHeapImp_mergeNodes___main___rarg(x_1, x_4, x_8);
+x_9 = l_Std_BinomialHeapImp_mergeNodes___rarg(x_1, x_4, x_8);
 x_10 = lean_alloc_ctor(1, 1, 0);
 lean_ctor_set(x_10, 0, x_9);
 return x_10;
@@ -643,6 +779,68 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_merge___rarg), 3, 0);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_head_x3f_match__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_head_x3f_match__2(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_head_x3f_match__2___rarg), 3, 0);
+return x_3;
+}
+}
 lean_object* l_Std_BinomialHeapImp_head_x3f___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -751,6 +949,56 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_head_x3f___rarg), 2, 0);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeapImp_head_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+else
+{
+lean_object* x_7; 
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+lean_dec(x_1);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; 
+lean_dec(x_4);
+x_8 = lean_box(0);
+x_9 = lean_apply_1(x_3, x_8);
+return x_9;
+}
+else
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_3);
+x_10 = lean_ctor_get(x_7, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_7, 1);
+lean_inc(x_11);
+lean_dec(x_7);
+x_12 = lean_apply_2(x_4, x_10, x_11);
+return x_12;
+}
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_head_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_head_match__1___rarg), 4, 0);
+return x_3;
+}
+}
 lean_object* l_Std_BinomialHeapImp_head___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -832,7 +1080,44 @@ lean_dec(x_1);
 return x_4;
 }
 }
-lean_object* l_Std_BinomialHeapImp_findMin___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_BinomialHeapImp_findMin_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_6; 
+lean_dec(x_5);
+x_6 = lean_apply_2(x_4, x_2, x_3);
+return x_6;
+}
+else
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+lean_dec(x_1);
+x_9 = lean_ctor_get(x_3, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_3, 1);
+lean_inc(x_10);
+lean_dec(x_3);
+x_11 = lean_apply_5(x_5, x_7, x_8, x_2, x_9, x_10);
+return x_11;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_findMin_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_findMin_match__1___rarg), 5, 0);
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeapImp_findMin___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -843,87 +1128,101 @@ return x_4;
 }
 else
 {
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; 
+lean_object* x_5; lean_object* x_6; uint8_t x_7; 
 x_5 = lean_ctor_get(x_2, 0);
 lean_inc(x_5);
 x_6 = lean_ctor_get(x_2, 1);
 lean_inc(x_6);
 lean_dec(x_2);
-x_7 = lean_ctor_get(x_4, 0);
-lean_inc(x_7);
-x_8 = lean_ctor_get(x_5, 0);
-lean_inc(x_8);
-x_9 = lean_ctor_get(x_7, 0);
-lean_inc(x_9);
-lean_dec(x_7);
-lean_inc(x_1);
-x_10 = lean_apply_2(x_1, x_8, x_9);
-x_11 = lean_unbox(x_10);
-lean_dec(x_10);
-if (x_11 == 0)
+x_7 = !lean_is_exclusive(x_4);
+if (x_7 == 0)
 {
-lean_object* x_12; lean_object* x_13; 
+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_8 = lean_ctor_get(x_4, 0);
+x_9 = lean_ctor_get(x_4, 1);
+x_10 = lean_ctor_get(x_5, 0);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_8, 0);
+lean_inc(x_11);
+lean_inc(x_1);
+x_12 = lean_apply_2(x_1, x_10, x_11);
+x_13 = lean_unbox(x_12);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_object* x_14; lean_object* x_15; 
 lean_dec(x_5);
-x_12 = lean_unsigned_to_nat(1u);
-x_13 = lean_nat_add(x_3, x_12);
+x_14 = lean_unsigned_to_nat(1u);
+x_15 = lean_nat_add(x_3, x_14);
 lean_dec(x_3);
 x_2 = x_6;
-x_3 = x_13;
+x_3 = x_15;
 goto _start;
 }
 else
 {
-uint8_t x_15; 
-x_15 = !lean_is_exclusive(x_4);
-if (x_15 == 0)
-{
-lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_16 = lean_ctor_get(x_4, 1);
-lean_dec(x_16);
-x_17 = lean_ctor_get(x_4, 0);
-lean_dec(x_17);
-x_18 = lean_unsigned_to_nat(1u);
-x_19 = lean_nat_add(x_3, x_18);
+lean_object* x_17; lean_object* x_18; 
+lean_dec(x_9);
+lean_dec(x_8);
+x_17 = lean_unsigned_to_nat(1u);
+x_18 = lean_nat_add(x_3, x_17);
 lean_ctor_set(x_4, 1, x_3);
 lean_ctor_set(x_4, 0, x_5);
 x_2 = x_6;
-x_3 = x_19;
+x_3 = x_18;
+goto _start;
+}
+}
+else
+{
+lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_20 = lean_ctor_get(x_4, 0);
+x_21 = lean_ctor_get(x_4, 1);
+lean_inc(x_21);
+lean_inc(x_20);
+lean_dec(x_4);
+x_22 = lean_ctor_get(x_5, 0);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_20, 0);
+lean_inc(x_23);
+lean_inc(x_1);
+x_24 = lean_apply_2(x_1, x_22, x_23);
+x_25 = lean_unbox(x_24);
+lean_dec(x_24);
+if (x_25 == 0)
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; 
+lean_dec(x_5);
+x_26 = lean_unsigned_to_nat(1u);
+x_27 = lean_nat_add(x_3, x_26);
+lean_dec(x_3);
+x_28 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_28, 0, x_20);
+lean_ctor_set(x_28, 1, x_21);
+x_2 = x_6;
+x_3 = x_27;
+x_4 = x_28;
 goto _start;
 }
 else
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-lean_dec(x_4);
-x_21 = lean_unsigned_to_nat(1u);
-x_22 = lean_nat_add(x_3, x_21);
-x_23 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_23, 0, x_5);
-lean_ctor_set(x_23, 1, x_3);
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+lean_dec(x_21);
+lean_dec(x_20);
+x_30 = lean_unsigned_to_nat(1u);
+x_31 = lean_nat_add(x_3, x_30);
+x_32 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_32, 0, x_5);
+lean_ctor_set(x_32, 1, x_3);
 x_2 = x_6;
-x_3 = x_22;
-x_4 = x_23;
+x_3 = x_31;
+x_4 = x_32;
 goto _start;
 }
 }
 }
 }
 }
-lean_object* l_Std_BinomialHeapImp_findMin___main(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_findMin___main___rarg), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Std_BinomialHeapImp_findMin___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Std_BinomialHeapImp_findMin___main___rarg(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
 lean_object* l_Std_BinomialHeapImp_findMin(lean_object* x_1) {
 _start:
 {
@@ -932,6 +1231,126 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_findMin___rarg), 4, 0);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeapImp_tail_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_2(x_3, x_6, x_7);
+return x_8;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_tail_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_tail_match__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeapImp_tail_match__2___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+x_3 = lean_ctor_get(x_1, 0);
+lean_inc(x_3);
+x_4 = lean_ctor_get(x_1, 1);
+lean_inc(x_4);
+lean_dec(x_1);
+x_5 = lean_apply_2(x_2, x_3, x_4);
+return x_5;
+}
+}
+lean_object* l_Std_BinomialHeapImp_tail_match__2(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_tail_match__2___rarg), 2, 0);
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeapImp_tail_match__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_5);
+lean_dec(x_4);
+lean_dec(x_3);
+x_6 = lean_box(0);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+else
+{
+lean_object* x_8; 
+lean_dec(x_2);
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+lean_dec(x_1);
+if (lean_obj_tag(x_8) == 0)
+{
+lean_object* x_9; lean_object* x_10; 
+lean_dec(x_5);
+lean_dec(x_4);
+x_9 = lean_box(0);
+x_10 = lean_apply_1(x_3, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_3);
+x_11 = lean_ctor_get(x_8, 1);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_object* x_12; lean_object* x_13; 
+lean_dec(x_5);
+x_12 = lean_ctor_get(x_8, 0);
+lean_inc(x_12);
+lean_dec(x_8);
+x_13 = lean_apply_1(x_4, x_12);
+return x_13;
+}
+else
+{
+lean_object* x_14; lean_object* x_15; 
+lean_dec(x_4);
+x_14 = lean_ctor_get(x_8, 0);
+lean_inc(x_14);
+x_15 = lean_apply_3(x_5, x_8, x_14, x_11);
+return x_15;
+}
+}
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_tail_match__3(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_tail_match__3___rarg), 5, 0);
+return x_3;
+}
+}
 lean_object* l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -1001,159 +1420,161 @@ _start:
 {
 if (lean_obj_tag(x_2) == 0)
 {
+lean_object* x_3; 
 lean_dec(x_1);
-return x_2;
+x_3 = lean_box(0);
+return x_3;
 }
 else
 {
-uint8_t x_3; 
-x_3 = !lean_is_exclusive(x_2);
-if (x_3 == 0)
-{
-lean_object* x_4; 
-x_4 = lean_ctor_get(x_2, 0);
-if (lean_obj_tag(x_4) == 0)
+uint8_t x_4; 
+x_4 = !lean_is_exclusive(x_2);
+if (x_4 == 0)
 {
 lean_object* x_5; 
-lean_free_object(x_2);
-lean_dec(x_1);
-x_5 = lean_box(0);
-return x_5;
-}
-else
+x_5 = lean_ctor_get(x_2, 0);
+if (lean_obj_tag(x_5) == 0)
 {
 lean_object* x_6; 
-x_6 = lean_ctor_get(x_4, 1);
-lean_inc(x_6);
-if (lean_obj_tag(x_6) == 0)
-{
-lean_object* x_7; lean_object* x_8; 
 lean_free_object(x_2);
-x_7 = lean_ctor_get(x_4, 0);
-lean_inc(x_7);
-lean_dec(x_4);
-x_8 = lean_ctor_get(x_7, 2);
-lean_inc(x_8);
-lean_dec(x_7);
-if (lean_obj_tag(x_8) == 0)
-{
-lean_object* x_9; 
 lean_dec(x_1);
-x_9 = lean_box(0);
-return x_9;
+x_6 = lean_box(0);
+return x_6;
 }
 else
 {
-lean_object* x_10; lean_object* x_11; lean_object* x_12; 
-x_10 = lean_ctor_get(x_8, 0);
-lean_inc(x_10);
-x_11 = lean_ctor_get(x_8, 1);
-lean_inc(x_11);
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_5, 1);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; lean_object* x_9; 
+lean_free_object(x_2);
+x_8 = lean_ctor_get(x_5, 0);
+lean_inc(x_8);
+lean_dec(x_5);
+x_9 = lean_ctor_get(x_8, 2);
+lean_inc(x_9);
 lean_dec(x_8);
-x_12 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__1___rarg(x_1, x_10, x_11);
-return x_12;
+if (lean_obj_tag(x_9) == 0)
+{
+lean_object* x_10; 
+lean_dec(x_1);
+x_10 = lean_box(0);
+return x_10;
+}
+else
+{
+lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+x_11 = lean_ctor_get(x_9, 0);
+lean_inc(x_11);
+x_12 = lean_ctor_get(x_9, 1);
+lean_inc(x_12);
+lean_dec(x_9);
+x_13 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__1___rarg(x_1, x_11, x_12);
+return x_13;
 }
 }
 else
 {
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; 
-x_13 = lean_ctor_get(x_4, 0);
-lean_inc(x_13);
-x_14 = lean_unsigned_to_nat(0u);
-x_15 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_15, 0, x_13);
-lean_ctor_set(x_15, 1, x_14);
-x_16 = lean_unsigned_to_nat(1u);
+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; 
+x_14 = lean_ctor_get(x_5, 0);
+lean_inc(x_14);
+x_15 = lean_unsigned_to_nat(0u);
+x_16 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_16, 0, x_14);
+lean_ctor_set(x_16, 1, x_15);
+x_17 = lean_unsigned_to_nat(1u);
 lean_inc(x_1);
-x_17 = l_Std_BinomialHeapImp_findMin___main___rarg(x_1, x_6, x_16, x_15);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_ctor_get(x_17, 1);
+x_18 = l_Std_BinomialHeapImp_findMin___rarg(x_1, x_7, x_17, x_16);
+x_19 = lean_ctor_get(x_18, 0);
 lean_inc(x_19);
-lean_dec(x_17);
-x_20 = l_List_eraseIdx___main___rarg(x_4, x_19);
-lean_dec(x_19);
-lean_ctor_set(x_2, 0, x_20);
-x_21 = lean_ctor_get(x_18, 2);
-lean_inc(x_21);
+x_20 = lean_ctor_get(x_18, 1);
+lean_inc(x_20);
 lean_dec(x_18);
-x_22 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__2___rarg(x_1, x_2, x_21);
-return x_22;
+x_21 = l_List_eraseIdx___main___rarg(x_5, x_20);
+lean_dec(x_20);
+lean_ctor_set(x_2, 0, x_21);
+x_22 = lean_ctor_get(x_19, 2);
+lean_inc(x_22);
+lean_dec(x_19);
+x_23 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__2___rarg(x_1, x_2, x_22);
+return x_23;
 }
 }
 }
 else
 {
-lean_object* x_23; 
-x_23 = lean_ctor_get(x_2, 0);
-lean_inc(x_23);
-lean_dec(x_2);
-if (lean_obj_tag(x_23) == 0)
-{
 lean_object* x_24; 
-lean_dec(x_1);
-x_24 = lean_box(0);
-return x_24;
-}
-else
+x_24 = lean_ctor_get(x_2, 0);
+lean_inc(x_24);
+lean_dec(x_2);
+if (lean_obj_tag(x_24) == 0)
 {
 lean_object* x_25; 
-x_25 = lean_ctor_get(x_23, 1);
-lean_inc(x_25);
-if (lean_obj_tag(x_25) == 0)
-{
-lean_object* x_26; lean_object* x_27; 
-x_26 = lean_ctor_get(x_23, 0);
-lean_inc(x_26);
-lean_dec(x_23);
-x_27 = lean_ctor_get(x_26, 2);
-lean_inc(x_27);
-lean_dec(x_26);
-if (lean_obj_tag(x_27) == 0)
-{
-lean_object* x_28; 
 lean_dec(x_1);
-x_28 = lean_box(0);
-return x_28;
+x_25 = lean_box(0);
+return x_25;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_29 = lean_ctor_get(x_27, 0);
-lean_inc(x_29);
-x_30 = lean_ctor_get(x_27, 1);
-lean_inc(x_30);
+lean_object* x_26; 
+x_26 = lean_ctor_get(x_24, 1);
+lean_inc(x_26);
+if (lean_obj_tag(x_26) == 0)
+{
+lean_object* x_27; lean_object* x_28; 
+x_27 = lean_ctor_get(x_24, 0);
+lean_inc(x_27);
+lean_dec(x_24);
+x_28 = lean_ctor_get(x_27, 2);
+lean_inc(x_28);
 lean_dec(x_27);
-x_31 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__1___rarg(x_1, x_29, x_30);
-return x_31;
+if (lean_obj_tag(x_28) == 0)
+{
+lean_object* x_29; 
+lean_dec(x_1);
+x_29 = lean_box(0);
+return x_29;
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; 
+x_30 = lean_ctor_get(x_28, 0);
+lean_inc(x_30);
+x_31 = lean_ctor_get(x_28, 1);
+lean_inc(x_31);
+lean_dec(x_28);
+x_32 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__1___rarg(x_1, x_30, x_31);
+return x_32;
 }
 }
 else
 {
-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; 
-x_32 = lean_ctor_get(x_23, 0);
-lean_inc(x_32);
-x_33 = lean_unsigned_to_nat(0u);
-x_34 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_34, 0, x_32);
-lean_ctor_set(x_34, 1, x_33);
-x_35 = lean_unsigned_to_nat(1u);
+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; 
+x_33 = lean_ctor_get(x_24, 0);
+lean_inc(x_33);
+x_34 = lean_unsigned_to_nat(0u);
+x_35 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_35, 0, x_33);
+lean_ctor_set(x_35, 1, x_34);
+x_36 = lean_unsigned_to_nat(1u);
 lean_inc(x_1);
-x_36 = l_Std_BinomialHeapImp_findMin___main___rarg(x_1, x_25, x_35, x_34);
-x_37 = lean_ctor_get(x_36, 0);
-lean_inc(x_37);
-x_38 = lean_ctor_get(x_36, 1);
+x_37 = l_Std_BinomialHeapImp_findMin___rarg(x_1, x_26, x_36, x_35);
+x_38 = lean_ctor_get(x_37, 0);
 lean_inc(x_38);
-lean_dec(x_36);
-x_39 = l_List_eraseIdx___main___rarg(x_23, x_38);
-lean_dec(x_38);
-x_40 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_40, 0, x_39);
-x_41 = lean_ctor_get(x_37, 2);
-lean_inc(x_41);
+x_39 = lean_ctor_get(x_37, 1);
+lean_inc(x_39);
 lean_dec(x_37);
-x_42 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__2___rarg(x_1, x_40, x_41);
-return x_42;
+x_40 = l_List_eraseIdx___main___rarg(x_24, x_39);
+lean_dec(x_39);
+x_41 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_41, 0, x_40);
+x_42 = lean_ctor_get(x_38, 2);
+lean_inc(x_42);
+lean_dec(x_38);
+x_43 = l_List_foldl___main___at_Std_BinomialHeapImp_tail___spec__2___rarg(x_1, x_41, x_42);
+return x_43;
 }
 }
 }
@@ -1168,7 +1589,66 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_tail___rarg), 2, 0);
 return x_2;
 }
 }
-lean_object* l_Std_BinomialHeapImp_toList___main___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_BinomialHeapImp_toList_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_3, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_toList_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_toList_match__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeapImp_toList_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; 
+lean_dec(x_2);
+x_6 = lean_apply_1(x_3, x_1);
+return x_6;
+}
+}
+}
+lean_object* l_Std_BinomialHeapImp_toList_match__2(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_toList_match__2___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeapImp_toList___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -1200,7 +1680,7 @@ lean_inc(x_6);
 lean_dec(x_4);
 lean_inc(x_1);
 x_7 = l_Std_BinomialHeapImp_tail___rarg(x_1, x_2);
-x_8 = l_Std_BinomialHeapImp_toList___main___rarg(x_1, x_7);
+x_8 = l_Std_BinomialHeapImp_toList___rarg(x_1, x_7);
 x_9 = lean_alloc_ctor(1, 2, 0);
 lean_ctor_set(x_9, 0, x_6);
 lean_ctor_set(x_9, 1, x_8);
@@ -1209,22 +1689,6 @@ return x_9;
 }
 }
 }
-lean_object* l_Std_BinomialHeapImp_toList___main(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeapImp_toList___main___rarg), 2, 0);
-return x_2;
-}
-}
-lean_object* l_Std_BinomialHeapImp_toList___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Std_BinomialHeapImp_toList___main___rarg(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Std_BinomialHeapImp_toList(lean_object* x_1) {
 _start:
 {
@@ -1267,6 +1731,31 @@ lean_dec(x_2);
 return x_3;
 }
 }
+lean_object* l_Std_BinomialHeap_isEmpty_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeap_isEmpty_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_BinomialHeap_isEmpty_match__1___rarg), 2, 0);
+return x_4;
+}
+}
+lean_object* l_Std_BinomialHeap_isEmpty_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Std_BinomialHeap_isEmpty_match__1(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
 uint8_t l_Std_BinomialHeap_isEmpty___rarg(lean_object* x_1) {
 _start:
 {
@@ -1327,6 +1816,31 @@ lean_dec(x_2);
 return x_3;
 }
 }
+lean_object* l_Std_BinomialHeap_merge_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_4(x_3, x_1, lean_box(0), x_2, lean_box(0));
+return x_4;
+}
+}
+lean_object* l_Std_BinomialHeap_merge_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_BinomialHeap_merge_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_BinomialHeap_merge_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Std_BinomialHeap_merge_match__1(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
 lean_object* l_Std_BinomialHeap_merge___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -1343,6 +1857,31 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeap_merge___rarg), 3, 0);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeap_head_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeap_head_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_BinomialHeap_head_match__1___rarg), 2, 0);
+return x_4;
+}
+}
+lean_object* l_Std_BinomialHeap_head_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Std_BinomialHeap_head_match__1(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
 lean_object* l_Std_BinomialHeap_head___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -1368,6 +1907,31 @@ lean_dec(x_2);
 return x_4;
 }
 }
+lean_object* l_Std_BinomialHeap_head_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeap_head_x3f_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_BinomialHeap_head_x3f_match__1___rarg), 2, 0);
+return x_4;
+}
+}
+lean_object* l_Std_BinomialHeap_head_x3f_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Std_BinomialHeap_head_x3f_match__1(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
 lean_object* l_Std_BinomialHeap_head_x3f___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1384,6 +1948,31 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeap_head_x3f___rarg), 2, 0);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeap_tail_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeap_tail_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_BinomialHeap_tail_match__1___rarg), 2, 0);
+return x_4;
+}
+}
+lean_object* l_Std_BinomialHeap_tail_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Std_BinomialHeap_tail_match__1(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
 lean_object* l_Std_BinomialHeap_tail___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -1417,11 +2006,36 @@ x_2 = lean_alloc_closure((void*)(l_Std_BinomialHeap_insert___rarg), 3, 0);
 return x_2;
 }
 }
+lean_object* l_Std_BinomialHeap_toList_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_BinomialHeap_toList_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_BinomialHeap_toList_match__1___rarg), 2, 0);
+return x_4;
+}
+}
+lean_object* l_Std_BinomialHeap_toList_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = l_Std_BinomialHeap_toList_match__1(x_1, x_2, x_3);
+lean_dec(x_2);
+return x_4;
+}
+}
 lean_object* l_Std_BinomialHeap_toList___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_BinomialHeapImp_toList___main___rarg(x_1, x_2);
+x_3 = l_Std_BinomialHeapImp_toList___rarg(x_1, x_2);
 return x_3;
 }
 }
diff --git a/stage0/stdlib/Std/Data/DList.c b/stage0/stdlib/Std/Data/DList.c
index ca7877569f..3d9d2fc4fe 100644
--- a/stage0/stdlib/Std/Data/DList.c
+++ b/stage0/stdlib/Std/Data/DList.c
@@ -14,34 +14,42 @@
 extern "C" {
 #endif
 lean_object* l_Std_DList_append___elambda__1(lean_object*);
+lean_object* l_Std_DList_push_match__1(lean_object*, lean_object*);
 lean_object* l_Std_DList_empty(lean_object*);
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
-lean_object* l_Std_DList_HasEmptyc___closed__1;
 lean_object* l_Std_DList_empty___elambda__1___rarg___boxed(lean_object*);
 lean_object* l_Std_DList_cons(lean_object*);
-lean_object* l_Std_DList_HasAppend___closed__1;
+lean_object* l_Std_DList_append_match__1(lean_object*, lean_object*);
+lean_object* l_Std_DList_Std_Data_DList___instance__2(lean_object*);
+lean_object* l_Std_DList_Std_Data_DList___instance__2___closed__1;
+lean_object* l_Std_DList_toList_match__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_DList_singleton___rarg(lean_object*);
 lean_object* l_Std_DList_append___rarg(lean_object*, lean_object*);
-lean_object* l_Std_DList_HasAppend(lean_object*);
+lean_object* l_Std_DList_push_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_DList_empty___closed__1;
 lean_object* l_Std_DList_singleton(lean_object*);
 lean_object* l_Std_DList_cons___elambda__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_DList_Std_Data_DList___instance__1(lean_object*);
 lean_object* l_Std_DList_singleton___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_DList_empty___elambda__1(lean_object*);
-lean_object* l_Std_DList_HasEmptyc(lean_object*);
 lean_object* l_Std_DList_ofList___elambda__1(lean_object*);
 lean_object* l_Std_DList_singleton___elambda__1(lean_object*);
+lean_object* l_Std_DList_Std_Data_DList___instance__1___closed__1;
 lean_object* l_Std_DList_push(lean_object*);
 lean_object* l_Std_DList_toList(lean_object*);
 lean_object* l_Std_DList_push___elambda__1(lean_object*);
 lean_object* l_Std_DList_toList___rarg(lean_object*);
 lean_object* l_Std_DList_cons___rarg(lean_object*, lean_object*);
 lean_object* l_Std_DList_push___elambda__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_DList_append_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_DList_append(lean_object*);
 lean_object* l_Std_DList_ofList(lean_object*);
+lean_object* l_Std_DList_cons_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_DList_ofList___rarg(lean_object*);
 lean_object* l_Std_DList_cons___elambda__1(lean_object*);
+lean_object* l_Std_DList_cons_match__1(lean_object*, lean_object*);
 lean_object* l_Std_DList_empty___elambda__1___rarg(lean_object*);
+lean_object* l_Std_DList_toList_match__1(lean_object*, lean_object*);
 lean_object* l_Std_DList_ofList___elambda__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_DList_push___rarg(lean_object*, lean_object*);
 lean_object* l_Std_DList_append___elambda__1___rarg(lean_object*, lean_object*, lean_object*);
@@ -118,7 +126,7 @@ lean_dec(x_1);
 return x_2;
 }
 }
-static lean_object* _init_l_Std_DList_HasEmptyc___closed__1() {
+static lean_object* _init_l_Std_DList_Std_Data_DList___instance__1___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -126,14 +134,30 @@ x_1 = lean_alloc_closure((void*)(l_Std_DList_empty___elambda__1___rarg___boxed),
 return x_1;
 }
 }
-lean_object* l_Std_DList_HasEmptyc(lean_object* x_1) {
+lean_object* l_Std_DList_Std_Data_DList___instance__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Std_DList_HasEmptyc___closed__1;
+x_2 = l_Std_DList_Std_Data_DList___instance__1___closed__1;
 return x_2;
 }
 }
+lean_object* l_Std_DList_toList_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_DList_toList_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_DList_toList_match__1___rarg), 2, 0);
+return x_3;
+}
+}
 lean_object* l_Std_DList_toList___rarg(lean_object* x_1) {
 _start:
 {
@@ -186,6 +210,22 @@ x_2 = lean_alloc_closure((void*)(l_Std_DList_singleton___rarg), 1, 0);
 return x_2;
 }
 }
+lean_object* l_Std_DList_cons_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, x_2, lean_box(0));
+return x_4;
+}
+}
+lean_object* l_Std_DList_cons_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_DList_cons_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 lean_object* l_Std_DList_cons___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -223,6 +263,22 @@ x_2 = lean_alloc_closure((void*)(l_Std_DList_cons___rarg), 2, 0);
 return x_2;
 }
 }
+lean_object* l_Std_DList_append_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_4(x_3, x_1, lean_box(0), x_2, lean_box(0));
+return x_4;
+}
+}
+lean_object* l_Std_DList_append_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_DList_append_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 lean_object* l_Std_DList_append___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -258,6 +314,22 @@ x_2 = lean_alloc_closure((void*)(l_Std_DList_append___rarg), 2, 0);
 return x_2;
 }
 }
+lean_object* l_Std_DList_push_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, lean_box(0), x_2);
+return x_4;
+}
+}
+lean_object* l_Std_DList_push_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_DList_push_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 lean_object* l_Std_DList_push___elambda__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -295,7 +367,7 @@ x_2 = lean_alloc_closure((void*)(l_Std_DList_push___rarg), 2, 0);
 return x_2;
 }
 }
-static lean_object* _init_l_Std_DList_HasAppend___closed__1() {
+static lean_object* _init_l_Std_DList_Std_Data_DList___instance__2___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -303,11 +375,11 @@ x_1 = lean_alloc_closure((void*)(l_Std_DList_append___rarg), 2, 0);
 return x_1;
 }
 }
-lean_object* l_Std_DList_HasAppend(lean_object* x_1) {
+lean_object* l_Std_DList_Std_Data_DList___instance__2(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Std_DList_HasAppend___closed__1;
+x_2 = l_Std_DList_Std_Data_DList___instance__2___closed__1;
 return x_2;
 }
 }
@@ -322,10 +394,10 @@ if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 l_Std_DList_empty___closed__1 = _init_l_Std_DList_empty___closed__1();
 lean_mark_persistent(l_Std_DList_empty___closed__1);
-l_Std_DList_HasEmptyc___closed__1 = _init_l_Std_DList_HasEmptyc___closed__1();
-lean_mark_persistent(l_Std_DList_HasEmptyc___closed__1);
-l_Std_DList_HasAppend___closed__1 = _init_l_Std_DList_HasAppend___closed__1();
-lean_mark_persistent(l_Std_DList_HasAppend___closed__1);
+l_Std_DList_Std_Data_DList___instance__1___closed__1 = _init_l_Std_DList_Std_Data_DList___instance__1___closed__1();
+lean_mark_persistent(l_Std_DList_Std_Data_DList___instance__1___closed__1);
+l_Std_DList_Std_Data_DList___instance__2___closed__1 = _init_l_Std_DList_Std_Data_DList___instance__2___closed__1();
+lean_mark_persistent(l_Std_DList_Std_Data_DList___instance__2___closed__1);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Std/Data/Queue.c b/stage0/stdlib/Std/Data/Queue.c
index c207fc0f37..3161e25cb1 100644
--- a/stage0/stdlib/Std/Data/Queue.c
+++ b/stage0/stdlib/Std/Data/Queue.c
@@ -14,19 +14,41 @@
 extern "C" {
 #endif
 lean_object* l_List_reverse___rarg(lean_object*);
+lean_object* l_Std_Queue_dList___default(lean_object*);
 lean_object* l_List_append___rarg(lean_object*, lean_object*);
 uint8_t l_Std_Queue_isEmpty___rarg(lean_object*);
 lean_object* l_Std_Queue_dequeue_x3f(lean_object*);
+lean_object* l_Std_Queue_dequeue_x3f_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Queue_enqueue(lean_object*);
 lean_object* l_Std_Queue_dequeue_x3f___rarg(lean_object*);
 lean_object* l_Std_Queue_empty___closed__1;
 lean_object* l_Std_Queue_enqueue___rarg(lean_object*, lean_object*);
+lean_object* l_Std_Queue_dequeue_x3f_match__2(lean_object*, lean_object*);
+lean_object* l_Std_Queue_eList___default(lean_object*);
 lean_object* l_Std_Queue_empty(lean_object*);
+lean_object* l_Std_Queue_dequeue_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_Queue_enqueueAll___rarg(lean_object*, lean_object*);
+lean_object* l_Std_Queue_dequeue_x3f_match__1(lean_object*, lean_object*);
 lean_object* l_Std_Queue_isEmpty___rarg___boxed(lean_object*);
 uint8_t l_List_isEmpty___rarg(lean_object*);
 lean_object* l_Std_Queue_enqueueAll(lean_object*);
 lean_object* l_Std_Queue_isEmpty(lean_object*);
+lean_object* l_Std_Queue_eList___default(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_box(0);
+return x_2;
+}
+}
+lean_object* l_Std_Queue_dList___default(lean_object* x_1) {
+_start:
+{
+lean_object* x_2; 
+x_2 = lean_box(0);
+return x_2;
+}
+}
 static lean_object* _init_l_Std_Queue_empty___closed__1() {
 _start:
 {
@@ -163,6 +185,72 @@ x_2 = lean_alloc_closure((void*)(l_Std_Queue_enqueueAll___rarg), 2, 0);
 return x_2;
 }
 }
+lean_object* l_Std_Queue_dequeue_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_2(x_3, x_6, x_7);
+return x_8;
+}
+}
+}
+lean_object* l_Std_Queue_dequeue_x3f_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_Queue_dequeue_x3f_match__1___rarg), 3, 0);
+return x_3;
+}
+}
+lean_object* l_Std_Queue_dequeue_x3f_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_apply_2(x_2, x_6, x_7);
+return x_8;
+}
+}
+}
+lean_object* l_Std_Queue_dequeue_x3f_match__2(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_Queue_dequeue_x3f_match__2___rarg), 3, 0);
+return x_3;
+}
+}
 lean_object* l_Std_Queue_dequeue_x3f___rarg(lean_object* x_1) {
 _start:
 {
@@ -189,97 +277,99 @@ return x_7;
 }
 else
 {
-lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 x_8 = lean_ctor_get(x_6, 0);
 lean_inc(x_8);
 x_9 = lean_ctor_get(x_6, 1);
 lean_inc(x_9);
 lean_dec(x_6);
+x_10 = lean_box(0);
 lean_ctor_set(x_1, 1, x_9);
-lean_ctor_set(x_1, 0, x_2);
-x_10 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_10, 0, x_8);
-lean_ctor_set(x_10, 1, x_1);
-x_11 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_11, 0, x_10);
-return x_11;
+lean_ctor_set(x_1, 0, x_10);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_8);
+lean_ctor_set(x_11, 1, x_1);
+x_12 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_12, 0, x_11);
+return x_12;
 }
 }
 else
 {
-lean_object* x_12; lean_object* x_13; 
-x_12 = lean_ctor_get(x_1, 0);
-lean_inc(x_12);
+lean_object* x_13; lean_object* x_14; 
+x_13 = lean_ctor_get(x_1, 0);
+lean_inc(x_13);
 lean_dec(x_1);
-x_13 = l_List_reverse___rarg(x_12);
-if (lean_obj_tag(x_13) == 0)
+x_14 = l_List_reverse___rarg(x_13);
+if (lean_obj_tag(x_14) == 0)
 {
-lean_object* x_14; 
-x_14 = lean_box(0);
-return x_14;
+lean_object* x_15; 
+x_15 = lean_box(0);
+return x_15;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
-x_15 = lean_ctor_get(x_13, 0);
-lean_inc(x_15);
-x_16 = lean_ctor_get(x_13, 1);
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_16 = lean_ctor_get(x_14, 0);
 lean_inc(x_16);
-lean_dec(x_13);
-x_17 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_17, 0, x_2);
-lean_ctor_set(x_17, 1, x_16);
-x_18 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_18, 0, x_15);
-lean_ctor_set(x_18, 1, x_17);
-x_19 = lean_alloc_ctor(1, 1, 0);
+x_17 = lean_ctor_get(x_14, 1);
+lean_inc(x_17);
+lean_dec(x_14);
+x_18 = lean_box(0);
+x_19 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_19, 0, x_18);
-return x_19;
+lean_ctor_set(x_19, 1, x_17);
+x_20 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_20, 0, x_16);
+lean_ctor_set(x_20, 1, x_19);
+x_21 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_21, 0, x_20);
+return x_21;
 }
 }
 }
 else
 {
-uint8_t x_20; 
-x_20 = !lean_is_exclusive(x_1);
-if (x_20 == 0)
+uint8_t x_22; 
+x_22 = !lean_is_exclusive(x_1);
+if (x_22 == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; 
-x_21 = lean_ctor_get(x_1, 1);
-lean_dec(x_21);
-x_22 = lean_ctor_get(x_2, 0);
-lean_inc(x_22);
-x_23 = lean_ctor_get(x_2, 1);
-lean_inc(x_23);
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; 
+x_23 = lean_ctor_get(x_1, 1);
+lean_dec(x_23);
+x_24 = lean_ctor_get(x_2, 0);
+lean_inc(x_24);
+x_25 = lean_ctor_get(x_2, 1);
+lean_inc(x_25);
 lean_dec(x_2);
-lean_ctor_set(x_1, 1, x_23);
-x_24 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_24, 0, x_22);
-lean_ctor_set(x_24, 1, x_1);
-x_25 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_25, 0, x_24);
-return x_25;
+lean_ctor_set(x_1, 1, x_25);
+x_26 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_26, 0, x_24);
+lean_ctor_set(x_26, 1, x_1);
+x_27 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_27, 0, x_26);
+return x_27;
 }
 else
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
-x_26 = lean_ctor_get(x_1, 0);
-lean_inc(x_26);
-lean_dec(x_1);
-x_27 = lean_ctor_get(x_2, 0);
-lean_inc(x_27);
-x_28 = lean_ctor_get(x_2, 1);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+x_28 = lean_ctor_get(x_1, 0);
 lean_inc(x_28);
+lean_dec(x_1);
+x_29 = lean_ctor_get(x_2, 0);
+lean_inc(x_29);
+x_30 = lean_ctor_get(x_2, 1);
+lean_inc(x_30);
 lean_dec(x_2);
-x_29 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_29, 0, x_26);
-lean_ctor_set(x_29, 1, x_28);
-x_30 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_30, 0, x_27);
-lean_ctor_set(x_30, 1, x_29);
-x_31 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_31, 0, x_30);
-return x_31;
+x_31 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_31, 0, x_28);
+lean_ctor_set(x_31, 1, x_30);
+x_32 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_32, 0, x_29);
+lean_ctor_set(x_32, 1, x_31);
+x_33 = lean_alloc_ctor(1, 1, 0);
+lean_ctor_set(x_33, 0, x_32);
+return x_33;
 }
 }
 }
diff --git a/stage0/stdlib/Std/Data/RBMap.c b/stage0/stdlib/Std/Data/RBMap.c
index cab0e2d845..f2626c58d1 100644
--- a/stage0/stdlib/Std/Data/RBMap.c
+++ b/stage0/stdlib/Std/Data/RBMap.c
@@ -13,230 +13,345 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-lean_object* l_Std_RBNode_find___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_min_match__2(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_find_x3f_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min_x21___rarg___closed__3;
+lean_object* l_Std_RBNode_fold_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_depth___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_contains___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_depth___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance2_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_find(lean_object*);
 lean_object* l_Std_RBMap_revFold(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_HasEmptyc___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_maxDepth(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_find___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance2_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_foldM___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_min___main___rarg(lean_object*);
 lean_object* l_Std_RBNode_del(lean_object*, lean_object*);
+lean_object* l_Std_RBMap_lowerBound_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_find_x21(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_fold___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_insert___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_ofList___rarg(lean_object*, lean_object*);
 lean_object* l_Std_mkRBMap___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__1;
+lean_object* l_Std_RBMap_insert_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance_u2083_match__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_rbmapOf___spec__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_min_match__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_singleton___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_erase(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_findCore(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_depth___main(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_max___rarg(lean_object*);
+lean_object* l_Std_RBMap_find_x3f_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_revFold___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_rbmapOf(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_any___boxed(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_Prod_HasRepr___rarg___closed__1;
-lean_object* l_Std_RBNode_foldM___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min_x21___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_all_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_max(lean_object*, lean_object*);
-lean_object* l___private_Init_Util_1__mkPanicMessage(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBMap_ofList___main(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_min___main(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_depth___main___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balance2(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_toList___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_depth(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_lowerBound___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_ofList_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_isEmpty_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_any(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_depth___rarg(lean_object*, lean_object*);
-lean_object* l_List_repr___at_Std_RBMap_HasRepr___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_min___rarg___boxed(lean_object*);
-lean_object* l_Std_RBNode_findCore___main(lean_object*, lean_object*);
 extern lean_object* l_String_splitAux___main___closed__1;
 lean_object* l_Std_RBNode_appendTrees(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max___rarg___boxed(lean_object*);
 lean_object* l_Std_RBMap_ofList(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main(lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__3;
 uint8_t l_Std_RBMap_all___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_foldM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBMap_ofList___main___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBMap_revFold_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balRight_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_any_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_List_repr___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_rbmapOf___spec__1(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance1_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_Std_Data_RBMap___instance__2___rarg___closed__1;
 lean_object* lean_nat_add(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max_x21___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_depth___main___rarg(lean_object*, lean_object*);
+lean_object* l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2(lean_object*, lean_object*);
+lean_object* l_Std_RBMap_find_x21___rarg___closed__3;
+lean_object* l_Std_RBMap_max_x21_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balRight_match__2___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balance2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_revFold_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_revFold___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_any___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_max_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_foldM_match__1___rarg(lean_object*, lean_object*, lean_object*);
 extern lean_object* l_ULift_HasRepr___rarg___closed__2;
+lean_object* l_Std_RBMap_fold_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_lowerBound_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_isEmpty_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object*);
+lean_object* l_Std_RBMap_max_match__2___rarg(lean_object*, lean_object*);
+lean_object* l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg(lean_object*, lean_object*, uint8_t, lean_object*);
 lean_object* l_Std_RBNode_max___rarg___boxed(lean_object*);
+lean_object* l_Std_RBMap_Std_Data_RBMap___instance__2___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Nat_max___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_depth___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert(lean_object*, lean_object*);
-lean_object* l_Std_RBMap_HasRepr___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balLeft_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_max_match__2(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_RBMap_fromList___spec__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_depth_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_isRed_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance_u2083_match__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_min_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_insert_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_rbmapOf___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_any(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_min_x21_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_find_x3f(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min_x21___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_min_x21___rarg___closed__4;
+lean_object* l_Std_RBNode_isBlack_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_any_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min_x21___rarg___closed__1;
-lean_object* l_Std_RBMap_HasRepr___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_max_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max_x21___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_all_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_toList(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_all(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_appendTrees___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_any_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_all_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_find_x21_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_erase_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balRight___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_mkRBMap(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBNode_isBlack___rarg(lean_object*);
 lean_object* l_Std_RBNode_del___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_min_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_findCore_x3f_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_fromList___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_size(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_max___main___rarg(lean_object*);
-uint8_t l_Std_RBNode_any___main___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_find_x3f___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_min___rarg(lean_object*);
 lean_object* l_Std_RBNode_erase___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_singleton(lean_object*, lean_object*);
 extern lean_object* l_List_repr___rarg___closed__2;
-lean_object* l_Std_HasEmptyc(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_all_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_any_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setRed___rarg(lean_object*);
 extern lean_object* l_List_reprAux___main___rarg___closed__1;
 lean_object* l_Std_RBMap_maxDepth___rarg(lean_object*);
+lean_object* l_Std_RBMap_min_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_fold_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_findCore_x3f_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_all(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min___rarg(lean_object*);
-lean_object* l_List_repr___at_Std_RBMap_HasRepr___spec__1(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_all___main(lean_object*, lean_object*);
+lean_object* l_Std_RBMap_max_x21___rarg___closed__2;
+lean_object* l_Std_RBNode_min_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees_match__3(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_find_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_isBlack_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min_x21___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_foldM_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_toList_match__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_find_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_isEmpty___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_max_match__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees_match__3___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max_x21___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_revFold_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balance1(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_foldM(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_erase_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_setRed(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balLeft___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_appendTrees___main___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(lean_object*, lean_object*);
+lean_object* l_List_repr___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_toList___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_find_x21___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_empty___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max_x21(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_isEmpty_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balance1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees_match__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_isRed_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_ins(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_any___main(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_max_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_toList_match__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_all___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_Std_Data_RBMap___instance__2(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_Std_Data_RBMap___instance__1___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_isBlack___rarg___boxed(lean_object*);
-lean_object* l_Std_RBNode_revFold___main___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_lowerBound_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max_x21___rarg___closed__1;
 lean_object* l_Std_RBNode_setBlack(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_del___main___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_toList_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_empty(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBMap_HasRepr(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_Std_Data_RBMap___instance__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_depth_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_find_x21___rarg___closed__2;
 lean_object* l_Std_RBNode_balance_u2083___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_find_x21___rarg___closed__1;
+lean_object* l_Std_RBMap_foldM_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_del___main(lean_object*, lean_object*);
-lean_object* l_Std_RBMap_HasRepr___rarg___closed__1;
 uint8_t l_Std_RBNode_isRed___rarg(lean_object*);
+lean_object* l_Std_RBMap_erase_match__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_erase___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_any___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_all___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_lowerBound___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_toList___rarg(lean_object*);
 lean_object* l_Std_RBMap_contains(lean_object*, lean_object*);
+lean_object* l_Std_RBMap_ofList_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_isRed___rarg___boxed(lean_object*);
 lean_object* lean_panic_fn(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_revFold___main(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_insert(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance1_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_setBlack_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance_u2083_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_findD(lean_object*, lean_object*);
 uint8_t l_Std_RBNode_any___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_findCore_x3f___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_all___main___rarg___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min___rarg___boxed(lean_object*);
 lean_object* l_Std_RBMap_maxDepth___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_toList___rarg___closed__1;
 lean_object* l_Std_RBMap_size___rarg___boxed(lean_object*);
+lean_object* l_Std_RBNode_setBlack_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_forM___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_forM___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min_x21(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_maxDepth___rarg___closed__1;
+lean_object* l_Std_RBNode_revFold_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_revFold(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_max___main(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_foldM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_findCore___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_find___main(lean_object*);
-lean_object* l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_size___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_ins___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_insert_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_isRed(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_ins___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_isBlack(lean_object*, lean_object*);
 uint8_t l_Std_RBMap_contains___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBNode_all___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balLeft(lean_object*, lean_object*);
+lean_object* l_Std_RBMap_revFold_match__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBMap_isEmpty___rarg(lean_object*);
-lean_object* l_Std_RBNode_min___main___rarg___boxed(lean_object*);
+lean_object* l_Std_RBMap_findCore_x3f_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_min_x21_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_RBMap_fromList___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_forM(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balLeft_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_setRed_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_lowerBound(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_findD___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_all___rarg___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg___boxed(lean_object*, lean_object*);
-lean_object* l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg(lean_object*, lean_object*, uint8_t, lean_object*);
-lean_object* l_Std_RBNode_lowerBound___main(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_appendTrees___main(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_ins_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balRight_match__2(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_isEmpty___rarg___boxed(lean_object*);
 lean_object* l_Std_RBMap_foldM(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_fold___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_isEmpty(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_lowerBound_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_max_x21_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_fold(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_max___rarg(lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_fold(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_depth___rarg___boxed(lean_object*, lean_object*);
-uint8_t l_Std_RBNode_all___main___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balance_u2083_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_Std_Data_RBMap___instance__2___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_fold_match__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_find_x21_match__1(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_size___rarg(lean_object*);
-lean_object* l_Std_RBNode_any___main___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balRight(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_findD___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBMap_min_match__2___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_balance_u2083(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_all_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_fromList(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_lowerBound(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_max___main___rarg___boxed(lean_object*);
+lean_object* l_Std_RBNode_setRed_match__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_erase(lean_object*, lean_object*);
 lean_object* l_Std_RBMap_revFold___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_balRight_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_maxDepth___rarg___boxed(lean_object*);
 lean_object* l_Std_RBNode_min(lean_object*, lean_object*);
+lean_object* l_Std_RBMap_max_match__1(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBMap_any___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_appendTrees_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l___private_Init_Util_2__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_del_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBNode_depth(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_lowerBound_match__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_findCore_x3f(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_any_match__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_fold___boxed(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBMap_min_x21___rarg___closed__2;
-lean_object* l_Std_RBNode_lowerBound___main___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_depth___main___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_depth_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_2);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_5(x_3, x_11, x_7, x_8, x_9, x_10);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_depth_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_depth_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_depth___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -252,9 +367,9 @@ lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_obj
 x_4 = lean_ctor_get(x_2, 0);
 x_5 = lean_ctor_get(x_2, 3);
 lean_inc(x_1);
-x_6 = l_Std_RBNode_depth___main___rarg(x_1, x_4);
+x_6 = l_Std_RBNode_depth___rarg(x_1, x_4);
 lean_inc(x_1);
-x_7 = l_Std_RBNode_depth___main___rarg(x_1, x_5);
+x_7 = l_Std_RBNode_depth___rarg(x_1, x_5);
 x_8 = lean_apply_2(x_1, x_6, x_7);
 x_9 = lean_unsigned_to_nat(1u);
 x_10 = lean_nat_add(x_8, x_9);
@@ -263,31 +378,6 @@ return x_10;
 }
 }
 }
-lean_object* l_Std_RBNode_depth___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_depth___main___rarg___boxed), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_depth___main___rarg___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Std_RBNode_depth___main___rarg(x_1, x_2);
-lean_dec(x_2);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_depth___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Std_RBNode_depth___main___rarg(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Std_RBNode_depth(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -305,7 +395,68 @@ lean_dec(x_2);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_min___main___rarg(lean_object* x_1) {
+lean_object* l_Std_RBNode_min_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+else
+{
+lean_object* x_7; 
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_4);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_9 = lean_ctor_get(x_1, 1);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 2);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_1, 3);
+lean_inc(x_11);
+lean_dec(x_1);
+x_12 = lean_box(x_8);
+x_13 = lean_apply_4(x_3, x_12, x_9, x_10, x_11);
+return x_13;
+}
+else
+{
+uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_3);
+x_14 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_15 = lean_ctor_get(x_1, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 2);
+lean_inc(x_16);
+x_17 = lean_ctor_get(x_1, 3);
+lean_inc(x_17);
+lean_dec(x_1);
+x_18 = lean_box(x_14);
+x_19 = lean_apply_5(x_4, x_18, x_7, x_15, x_16, x_17);
+return x_19;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_min_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_min_match__1___rarg), 4, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_min___rarg(lean_object* x_1) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -340,31 +491,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_min___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_min___main___rarg___boxed), 1, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_min___main___rarg___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Std_RBNode_min___main___rarg(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_Std_RBNode_min___rarg(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Std_RBNode_min___main___rarg(x_1);
-return x_2;
-}
-}
 lean_object* l_Std_RBNode_min(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -382,7 +508,68 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_max___main___rarg(lean_object* x_1) {
+lean_object* l_Std_RBNode_max_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; lean_object* x_6; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_5 = lean_box(0);
+x_6 = lean_apply_1(x_2, x_5);
+return x_6;
+}
+else
+{
+lean_object* x_7; 
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+uint8_t x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_4);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_1, 2);
+lean_inc(x_11);
+lean_dec(x_1);
+x_12 = lean_box(x_8);
+x_13 = lean_apply_4(x_3, x_12, x_9, x_10, x_11);
+return x_13;
+}
+else
+{
+uint8_t x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; 
+lean_dec(x_3);
+x_14 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_15 = lean_ctor_get(x_1, 0);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 1);
+lean_inc(x_16);
+x_17 = lean_ctor_get(x_1, 2);
+lean_inc(x_17);
+lean_dec(x_1);
+x_18 = lean_box(x_14);
+x_19 = lean_apply_5(x_4, x_18, x_15, x_16, x_17, x_7);
+return x_19;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_max_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_max_match__1___rarg), 4, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_max___rarg(lean_object* x_1) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -417,31 +604,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_max___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_max___main___rarg___boxed), 1, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_max___main___rarg___boxed(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Std_RBNode_max___main___rarg(x_1);
-lean_dec(x_1);
-return x_2;
-}
-}
-lean_object* l_Std_RBNode_max___rarg(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = l_Std_RBNode_max___main___rarg(x_1);
-return x_2;
-}
-}
 lean_object* l_Std_RBNode_max(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -459,7 +621,45 @@ lean_dec(x_1);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_fold___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_fold_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_4);
+x_5 = lean_apply_1(x_3, x_1);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_3);
+x_6 = lean_ctor_get_uint8(x_2, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_2, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_2, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_2, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_2, 3);
+lean_inc(x_10);
+lean_dec(x_2);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_6(x_4, x_1, x_11, x_7, x_8, x_9, x_10);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_fold_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBNode_fold_match__1___rarg), 4, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBNode_fold___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -480,7 +680,7 @@ x_7 = lean_ctor_get(x_3, 3);
 lean_inc(x_7);
 lean_dec(x_3);
 lean_inc(x_1);
-x_8 = l_Std_RBNode_fold___main___rarg(x_1, x_2, x_4);
+x_8 = l_Std_RBNode_fold___rarg(x_1, x_2, x_4);
 lean_inc(x_1);
 x_9 = lean_apply_3(x_1, x_8, x_5, x_6);
 x_2 = x_9;
@@ -489,22 +689,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Std_RBNode_fold___main___rarg), 3, 0);
-return x_4;
-}
-}
-lean_object* l_Std_RBNode_fold___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Std_RBNode_fold___main___rarg(x_1, x_2, x_3);
-return x_4;
-}
-}
 lean_object* l_Std_RBNode_fold(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -513,21 +697,60 @@ x_4 = lean_alloc_closure((void*)(l_Std_RBNode_fold___rarg), 3, 0);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_2);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_5(x_3, x_11, x_7, x_8, x_9, x_10);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_foldM_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_foldM_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_foldM___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___rarg(x_1, x_2, x_4, x_3);
+x_5 = l_Std_RBNode_foldM___rarg(x_1, x_2, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Std_RBNode_foldM___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
 lean_object* x_8; lean_object* x_9; lean_object* x_10; 
 lean_inc(x_1);
 x_8 = lean_apply_3(x_1, x_7, x_2, x_3);
-x_9 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___rarg___lambda__1), 4, 3);
+x_9 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___rarg___lambda__1), 4, 3);
 lean_closure_set(x_9, 0, x_4);
 lean_closure_set(x_9, 1, x_1);
 lean_closure_set(x_9, 2, x_5);
@@ -535,7 +758,7 @@ x_10 = lean_apply_4(x_6, lean_box(0), lean_box(0), x_8, x_9);
 return x_10;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___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)
@@ -567,9 +790,9 @@ x_12 = lean_ctor_get(x_1, 1);
 lean_inc(x_12);
 lean_inc(x_2);
 lean_inc(x_1);
-x_13 = l_Std_RBNode_foldM___main___rarg(x_1, x_2, x_3, x_8);
+x_13 = l_Std_RBNode_foldM___rarg(x_1, x_2, x_3, x_8);
 lean_inc(x_12);
-x_14 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___rarg___lambda__2), 7, 6);
+x_14 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___rarg___lambda__2), 7, 6);
 lean_closure_set(x_14, 0, x_2);
 lean_closure_set(x_14, 1, x_9);
 lean_closure_set(x_14, 2, x_10);
@@ -581,22 +804,6 @@ return x_15;
 }
 }
 }
-lean_object* l_Std_RBNode_foldM___main(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___rarg), 4, 0);
-return x_5;
-}
-}
-lean_object* l_Std_RBNode_foldM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___rarg(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
 lean_object* l_Std_RBNode_foldM(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -605,7 +812,46 @@ x_5 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___rarg), 4, 0);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_revFold___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_revFold_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_2);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_5(x_3, x_11, x_7, x_8, x_9, x_10);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_revFold_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_revFold_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_revFold___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -626,7 +872,7 @@ x_7 = lean_ctor_get(x_3, 3);
 lean_inc(x_7);
 lean_dec(x_3);
 lean_inc(x_1);
-x_8 = l_Std_RBNode_revFold___main___rarg(x_1, x_2, x_7);
+x_8 = l_Std_RBNode_revFold___rarg(x_1, x_2, x_7);
 lean_inc(x_1);
 x_9 = lean_apply_3(x_1, x_8, x_5, x_6);
 x_2 = x_9;
@@ -635,22 +881,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_revFold___main(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Std_RBNode_revFold___main___rarg), 3, 0);
-return x_4;
-}
-}
-lean_object* l_Std_RBNode_revFold___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Std_RBNode_revFold___main___rarg(x_1, x_2, x_3);
-return x_4;
-}
-}
 lean_object* l_Std_RBNode_revFold(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -659,7 +889,46 @@ x_4 = lean_alloc_closure((void*)(l_Std_RBNode_revFold___rarg), 3, 0);
 return x_4;
 }
 }
-uint8_t l_Std_RBNode_all___main___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_all_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_2);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_5(x_3, x_11, x_7, x_8, x_9, x_10);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_all_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_all_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+uint8_t l_Std_RBNode_all___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -698,7 +967,7 @@ else
 {
 uint8_t x_11; 
 lean_inc(x_1);
-x_11 = l_Std_RBNode_all___main___rarg(x_1, x_4);
+x_11 = l_Std_RBNode_all___rarg(x_1, x_4);
 if (x_11 == 0)
 {
 uint8_t x_12; 
@@ -716,31 +985,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_all___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_all___main___rarg___boxed), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_all___main___rarg___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_all___main___rarg(x_1, x_2);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-uint8_t l_Std_RBNode_all___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = l_Std_RBNode_all___main___rarg(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Std_RBNode_all(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -758,7 +1002,46 @@ x_4 = lean_box(x_3);
 return x_4;
 }
 }
-uint8_t l_Std_RBNode_any___main___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_any_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_2);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_5(x_3, x_11, x_7, x_8, x_9, x_10);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_any_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_any_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+uint8_t l_Std_RBNode_any___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -788,7 +1071,7 @@ if (x_9 == 0)
 {
 uint8_t x_10; 
 lean_inc(x_1);
-x_10 = l_Std_RBNode_any___main___rarg(x_1, x_4);
+x_10 = l_Std_RBNode_any___rarg(x_1, x_4);
 if (x_10 == 0)
 {
 x_2 = x_7;
@@ -815,31 +1098,6 @@ return x_13;
 }
 }
 }
-lean_object* l_Std_RBNode_any___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_any___main___rarg___boxed), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_any___main___rarg___boxed(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_any___main___rarg(x_1, x_2);
-x_4 = lean_box(x_3);
-return x_4;
-}
-}
-uint8_t l_Std_RBNode_any___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-uint8_t x_3; 
-x_3 = l_Std_RBNode_any___main___rarg(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Std_RBNode_any(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -880,714 +1138,951 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_singleton___rarg), 2, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_balance1_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+if (lean_obj_tag(x_4) == 0)
+{
+lean_object* x_9; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_9 = lean_apply_4(x_8, x_1, x_2, x_3, x_4);
+return x_9;
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_8);
+x_10 = lean_ctor_get(x_4, 0);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_object* x_11; 
+lean_dec(x_5);
+x_11 = lean_ctor_get(x_4, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_6);
+x_12 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_13 = lean_ctor_get(x_4, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get(x_4, 2);
+lean_inc(x_14);
+lean_dec(x_4);
+x_15 = lean_box(x_12);
+x_16 = lean_apply_8(x_7, x_1, x_2, x_3, x_15, x_11, x_13, x_14, x_11);
+return x_16;
+}
+else
+{
+uint8_t x_17; 
+x_17 = lean_ctor_get_uint8(x_11, sizeof(void*)*4);
+if (x_17 == 0)
+{
+uint8_t 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_dec(x_7);
+x_18 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_19 = lean_ctor_get(x_4, 1);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_4, 2);
+lean_inc(x_20);
+lean_dec(x_4);
+x_21 = lean_ctor_get(x_11, 0);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_11, 1);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_11, 2);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_11, 3);
+lean_inc(x_24);
+lean_dec(x_11);
+x_25 = lean_box(x_18);
+x_26 = lean_apply_11(x_6, x_1, x_2, x_3, x_25, x_10, x_19, x_20, x_21, x_22, x_23, x_24);
+return x_26;
+}
+else
+{
+uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_6);
+x_27 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_28 = lean_ctor_get(x_4, 1);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_4, 2);
+lean_inc(x_29);
+lean_dec(x_4);
+x_30 = lean_box(x_27);
+x_31 = lean_apply_8(x_7, x_1, x_2, x_3, x_30, x_10, x_28, x_29, x_11);
+return x_31;
+}
+}
+}
+else
+{
+uint8_t x_32; 
+x_32 = lean_ctor_get_uint8(x_10, sizeof(void*)*4);
+if (x_32 == 0)
+{
+uint8_t 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_dec(x_7);
+lean_dec(x_6);
+x_33 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_34 = lean_ctor_get(x_4, 1);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_4, 2);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_4, 3);
+lean_inc(x_36);
+lean_dec(x_4);
+x_37 = lean_ctor_get(x_10, 0);
+lean_inc(x_37);
+x_38 = lean_ctor_get(x_10, 1);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_10, 2);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_10, 3);
+lean_inc(x_40);
+lean_dec(x_10);
+x_41 = lean_box(x_33);
+x_42 = lean_apply_11(x_5, x_1, x_2, x_3, x_41, x_37, x_38, x_39, x_40, x_34, x_35, x_36);
+return x_42;
+}
+else
+{
+lean_object* x_43; 
+lean_dec(x_5);
+x_43 = lean_ctor_get(x_4, 3);
+lean_inc(x_43);
+if (lean_obj_tag(x_43) == 0)
+{
+uint8_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_6);
+x_44 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_45 = lean_ctor_get(x_4, 1);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_4, 2);
+lean_inc(x_46);
+lean_dec(x_4);
+x_47 = lean_box(x_44);
+x_48 = lean_apply_8(x_7, x_1, x_2, x_3, x_47, x_10, x_45, x_46, x_43);
+return x_48;
+}
+else
+{
+uint8_t x_49; 
+x_49 = lean_ctor_get_uint8(x_43, sizeof(void*)*4);
+if (x_49 == 0)
+{
+uint8_t 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_dec(x_7);
+x_50 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_51 = lean_ctor_get(x_4, 1);
+lean_inc(x_51);
+x_52 = lean_ctor_get(x_4, 2);
+lean_inc(x_52);
+lean_dec(x_4);
+x_53 = lean_ctor_get(x_43, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_43, 1);
+lean_inc(x_54);
+x_55 = lean_ctor_get(x_43, 2);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_43, 3);
+lean_inc(x_56);
+lean_dec(x_43);
+x_57 = lean_box(x_50);
+x_58 = lean_apply_11(x_6, x_1, x_2, x_3, x_57, x_10, x_51, x_52, x_53, x_54, x_55, x_56);
+return x_58;
+}
+else
+{
+uint8_t x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+lean_dec(x_6);
+x_59 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_60 = lean_ctor_get(x_4, 1);
+lean_inc(x_60);
+x_61 = lean_ctor_get(x_4, 2);
+lean_inc(x_61);
+lean_dec(x_4);
+x_62 = !lean_is_exclusive(x_10);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; 
+lean_ctor_set_uint8(x_10, sizeof(void*)*4, x_49);
+x_63 = lean_box(x_59);
+x_64 = lean_apply_8(x_7, x_1, x_2, x_3, x_63, x_10, x_60, x_61, x_43);
+return x_64;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_65 = lean_ctor_get(x_10, 0);
+x_66 = lean_ctor_get(x_10, 1);
+x_67 = lean_ctor_get(x_10, 2);
+x_68 = lean_ctor_get(x_10, 3);
+lean_inc(x_68);
+lean_inc(x_67);
+lean_inc(x_66);
+lean_inc(x_65);
+lean_dec(x_10);
+x_69 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_69, 0, x_65);
+lean_ctor_set(x_69, 1, x_66);
+lean_ctor_set(x_69, 2, x_67);
+lean_ctor_set(x_69, 3, x_68);
+lean_ctor_set_uint8(x_69, sizeof(void*)*4, x_49);
+x_70 = lean_box(x_59);
+x_71 = lean_apply_8(x_7, x_1, x_2, x_3, x_70, x_69, x_60, x_61, x_43);
+return x_71;
+}
+}
+}
+}
+}
+}
+}
+}
+lean_object* l_Std_RBNode_balance1_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_balance1_match__1___rarg), 8, 0);
+return x_4;
+}
+}
 lean_object* l_Std_RBNode_balance1___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_object* x_5; 
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_4;
+x_5 = lean_box(0);
+return x_5;
 }
 else
 {
-lean_object* x_5; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-if (lean_obj_tag(x_5) == 0)
-{
 lean_object* x_6; 
-x_6 = lean_ctor_get(x_4, 3);
+x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
 if (lean_obj_tag(x_6) == 0)
 {
-uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_4);
-if (x_7 == 0)
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_4, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_8; lean_object* x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
-x_8 = lean_ctor_get(x_4, 3);
-lean_dec(x_8);
-x_9 = lean_ctor_get(x_4, 0);
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_4);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_4, 3);
 lean_dec(x_9);
-x_10 = 0;
-lean_ctor_set(x_4, 0, x_6);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_10);
-x_11 = 1;
-x_12 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_12, 0, x_4);
-lean_ctor_set(x_12, 1, x_1);
-lean_ctor_set(x_12, 2, x_2);
-lean_ctor_set(x_12, 3, x_3);
-lean_ctor_set_uint8(x_12, sizeof(void*)*4, x_11);
-return x_12;
+x_10 = lean_ctor_get(x_4, 0);
+lean_dec(x_10);
+x_11 = 0;
+lean_ctor_set(x_4, 0, x_7);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_11);
+x_12 = 1;
+x_13 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_13, 0, x_4);
+lean_ctor_set(x_13, 1, x_1);
+lean_ctor_set(x_13, 2, x_2);
+lean_ctor_set(x_13, 3, x_3);
+lean_ctor_set_uint8(x_13, sizeof(void*)*4, x_12);
+return x_13;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; 
-x_13 = lean_ctor_get(x_4, 1);
-x_14 = lean_ctor_get(x_4, 2);
+lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; 
+x_14 = lean_ctor_get(x_4, 1);
+x_15 = lean_ctor_get(x_4, 2);
+lean_inc(x_15);
 lean_inc(x_14);
-lean_inc(x_13);
 lean_dec(x_4);
-x_15 = 0;
-x_16 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_16, 0, x_6);
-lean_ctor_set(x_16, 1, x_13);
-lean_ctor_set(x_16, 2, x_14);
-lean_ctor_set(x_16, 3, x_6);
-lean_ctor_set_uint8(x_16, sizeof(void*)*4, x_15);
-x_17 = 1;
-x_18 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_18, 0, x_16);
-lean_ctor_set(x_18, 1, x_1);
-lean_ctor_set(x_18, 2, x_2);
-lean_ctor_set(x_18, 3, x_3);
-lean_ctor_set_uint8(x_18, sizeof(void*)*4, x_17);
-return x_18;
+x_16 = 0;
+x_17 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_17, 0, x_7);
+lean_ctor_set(x_17, 1, x_14);
+lean_ctor_set(x_17, 2, x_15);
+lean_ctor_set(x_17, 3, x_7);
+lean_ctor_set_uint8(x_17, sizeof(void*)*4, x_16);
+x_18 = 1;
+x_19 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_19, 0, x_17);
+lean_ctor_set(x_19, 1, x_1);
+lean_ctor_set(x_19, 2, x_2);
+lean_ctor_set(x_19, 3, x_3);
+lean_ctor_set_uint8(x_19, sizeof(void*)*4, x_18);
+return x_19;
 }
 }
 else
 {
-uint8_t x_19; 
-x_19 = lean_ctor_get_uint8(x_6, sizeof(void*)*4);
-if (x_19 == 0)
-{
 uint8_t x_20; 
-x_20 = !lean_is_exclusive(x_4);
+x_20 = lean_ctor_get_uint8(x_7, sizeof(void*)*4);
 if (x_20 == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_21 = lean_ctor_get(x_4, 1);
-x_22 = lean_ctor_get(x_4, 2);
-x_23 = lean_ctor_get(x_4, 3);
-lean_dec(x_23);
-x_24 = lean_ctor_get(x_4, 0);
-lean_dec(x_24);
-x_25 = !lean_is_exclusive(x_6);
-if (x_25 == 0)
+uint8_t x_21; 
+x_21 = !lean_is_exclusive(x_4);
+if (x_21 == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 
-x_26 = lean_ctor_get(x_6, 0);
-x_27 = lean_ctor_get(x_6, 1);
-x_28 = lean_ctor_get(x_6, 2);
-x_29 = lean_ctor_get(x_6, 3);
-x_30 = 1;
-lean_ctor_set(x_6, 3, x_26);
-lean_ctor_set(x_6, 2, x_22);
-lean_ctor_set(x_6, 1, x_21);
-lean_ctor_set(x_6, 0, x_5);
-lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_30);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_22 = lean_ctor_get(x_4, 1);
+x_23 = lean_ctor_get(x_4, 2);
+x_24 = lean_ctor_get(x_4, 3);
+lean_dec(x_24);
+x_25 = lean_ctor_get(x_4, 0);
+lean_dec(x_25);
+x_26 = !lean_is_exclusive(x_7);
+if (x_26 == 0)
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; uint8_t x_32; lean_object* x_33; 
+x_27 = lean_ctor_get(x_7, 0);
+x_28 = lean_ctor_get(x_7, 1);
+x_29 = lean_ctor_get(x_7, 2);
+x_30 = lean_ctor_get(x_7, 3);
+x_31 = 1;
+lean_ctor_set(x_7, 3, x_27);
+lean_ctor_set(x_7, 2, x_23);
+lean_ctor_set(x_7, 1, x_22);
+lean_ctor_set(x_7, 0, x_6);
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_31);
 lean_ctor_set(x_4, 3, x_3);
 lean_ctor_set(x_4, 2, x_2);
 lean_ctor_set(x_4, 1, x_1);
-lean_ctor_set(x_4, 0, x_29);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_30);
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_6);
-lean_ctor_set(x_31, 1, x_27);
-lean_ctor_set(x_31, 2, x_28);
-lean_ctor_set(x_31, 3, x_4);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_19);
-return x_31;
+lean_ctor_set(x_4, 0, x_30);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_31);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_7);
+lean_ctor_set(x_33, 1, x_28);
+lean_ctor_set(x_33, 2, x_29);
+lean_ctor_set(x_33, 3, x_4);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; 
-x_32 = lean_ctor_get(x_6, 0);
-x_33 = lean_ctor_get(x_6, 1);
-x_34 = lean_ctor_get(x_6, 2);
-x_35 = lean_ctor_get(x_6, 3);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; 
+x_34 = lean_ctor_get(x_7, 0);
+x_35 = lean_ctor_get(x_7, 1);
+x_36 = lean_ctor_get(x_7, 2);
+x_37 = lean_ctor_get(x_7, 3);
+lean_inc(x_37);
+lean_inc(x_36);
 lean_inc(x_35);
 lean_inc(x_34);
-lean_inc(x_33);
-lean_inc(x_32);
-lean_dec(x_6);
-x_36 = 1;
-x_37 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_37, 0, x_5);
-lean_ctor_set(x_37, 1, x_21);
-lean_ctor_set(x_37, 2, x_22);
-lean_ctor_set(x_37, 3, x_32);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
+lean_dec(x_7);
+x_38 = 1;
+x_39 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_39, 0, x_6);
+lean_ctor_set(x_39, 1, x_22);
+lean_ctor_set(x_39, 2, x_23);
+lean_ctor_set(x_39, 3, x_34);
+lean_ctor_set_uint8(x_39, sizeof(void*)*4, x_38);
 lean_ctor_set(x_4, 3, x_3);
 lean_ctor_set(x_4, 2, x_2);
 lean_ctor_set(x_4, 1, x_1);
-lean_ctor_set(x_4, 0, x_35);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_36);
-x_38 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_38, 0, x_37);
-lean_ctor_set(x_38, 1, x_33);
-lean_ctor_set(x_38, 2, x_34);
-lean_ctor_set(x_38, 3, x_4);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_19);
-return x_38;
+lean_ctor_set(x_4, 0, x_37);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_38);
+x_40 = 0;
+x_41 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_35);
+lean_ctor_set(x_41, 2, x_36);
+lean_ctor_set(x_41, 3, x_4);
+lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_40);
+return x_41;
 }
 }
 else
 {
-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; uint8_t x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_39 = lean_ctor_get(x_4, 1);
-x_40 = lean_ctor_get(x_4, 2);
-lean_inc(x_40);
-lean_inc(x_39);
-lean_dec(x_4);
-x_41 = lean_ctor_get(x_6, 0);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_6, 1);
-lean_inc(x_42);
-x_43 = lean_ctor_get(x_6, 2);
+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; uint8_t x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; 
+x_42 = lean_ctor_get(x_4, 1);
+x_43 = lean_ctor_get(x_4, 2);
 lean_inc(x_43);
-x_44 = lean_ctor_get(x_6, 3);
+lean_inc(x_42);
+lean_dec(x_4);
+x_44 = lean_ctor_get(x_7, 0);
 lean_inc(x_44);
+x_45 = lean_ctor_get(x_7, 1);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_7, 2);
+lean_inc(x_46);
+x_47 = lean_ctor_get(x_7, 3);
+lean_inc(x_47);
+if (lean_is_exclusive(x_7)) {
+ lean_ctor_release(x_7, 0);
+ lean_ctor_release(x_7, 1);
+ lean_ctor_release(x_7, 2);
+ lean_ctor_release(x_7, 3);
+ x_48 = x_7;
+} else {
+ lean_dec_ref(x_7);
+ x_48 = lean_box(0);
+}
+x_49 = 1;
+if (lean_is_scalar(x_48)) {
+ x_50 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_50 = x_48;
+}
+lean_ctor_set(x_50, 0, x_6);
+lean_ctor_set(x_50, 1, x_42);
+lean_ctor_set(x_50, 2, x_43);
+lean_ctor_set(x_50, 3, x_44);
+lean_ctor_set_uint8(x_50, sizeof(void*)*4, x_49);
+x_51 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_51, 0, x_47);
+lean_ctor_set(x_51, 1, x_1);
+lean_ctor_set(x_51, 2, x_2);
+lean_ctor_set(x_51, 3, x_3);
+lean_ctor_set_uint8(x_51, sizeof(void*)*4, x_49);
+x_52 = 0;
+x_53 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_53, 0, x_50);
+lean_ctor_set(x_53, 1, x_45);
+lean_ctor_set(x_53, 2, x_46);
+lean_ctor_set(x_53, 3, x_51);
+lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_52);
+return x_53;
+}
+}
+else
+{
+uint8_t x_54; 
+x_54 = !lean_is_exclusive(x_4);
+if (x_54 == 0)
+{
+lean_object* x_55; lean_object* x_56; uint8_t x_57; uint8_t x_58; lean_object* x_59; 
+x_55 = lean_ctor_get(x_4, 3);
+lean_dec(x_55);
+x_56 = lean_ctor_get(x_4, 0);
+lean_dec(x_56);
+x_57 = 0;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_57);
+x_58 = 1;
+x_59 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_59, 0, x_4);
+lean_ctor_set(x_59, 1, x_1);
+lean_ctor_set(x_59, 2, x_2);
+lean_ctor_set(x_59, 3, x_3);
+lean_ctor_set_uint8(x_59, sizeof(void*)*4, x_58);
+return x_59;
+}
+else
+{
+lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; uint8_t x_64; lean_object* x_65; 
+x_60 = lean_ctor_get(x_4, 1);
+x_61 = lean_ctor_get(x_4, 2);
+lean_inc(x_61);
+lean_inc(x_60);
+lean_dec(x_4);
+x_62 = 0;
+x_63 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_63, 0, x_6);
+lean_ctor_set(x_63, 1, x_60);
+lean_ctor_set(x_63, 2, x_61);
+lean_ctor_set(x_63, 3, x_7);
+lean_ctor_set_uint8(x_63, sizeof(void*)*4, x_62);
+x_64 = 1;
+x_65 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_65, 0, x_63);
+lean_ctor_set(x_65, 1, x_1);
+lean_ctor_set(x_65, 2, x_2);
+lean_ctor_set(x_65, 3, x_3);
+lean_ctor_set_uint8(x_65, sizeof(void*)*4, x_64);
+return x_65;
+}
+}
+}
+}
+else
+{
+uint8_t x_66; 
+x_66 = lean_ctor_get_uint8(x_6, sizeof(void*)*4);
+if (x_66 == 0)
+{
+uint8_t x_67; 
+x_67 = !lean_is_exclusive(x_4);
+if (x_67 == 0)
+{
+lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; uint8_t x_72; 
+x_68 = lean_ctor_get(x_4, 1);
+x_69 = lean_ctor_get(x_4, 2);
+x_70 = lean_ctor_get(x_4, 3);
+x_71 = lean_ctor_get(x_4, 0);
+lean_dec(x_71);
+x_72 = !lean_is_exclusive(x_6);
+if (x_72 == 0)
+{
+uint8_t x_73; uint8_t x_74; lean_object* x_75; 
+x_73 = 1;
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_73);
+lean_ctor_set(x_4, 3, x_3);
+lean_ctor_set(x_4, 2, x_2);
+lean_ctor_set(x_4, 1, x_1);
+lean_ctor_set(x_4, 0, x_70);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_73);
+x_74 = 0;
+x_75 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_75, 0, x_6);
+lean_ctor_set(x_75, 1, x_68);
+lean_ctor_set(x_75, 2, x_69);
+lean_ctor_set(x_75, 3, x_4);
+lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
+return x_75;
+}
+else
+{
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; lean_object* x_81; uint8_t x_82; lean_object* x_83; 
+x_76 = lean_ctor_get(x_6, 0);
+x_77 = lean_ctor_get(x_6, 1);
+x_78 = lean_ctor_get(x_6, 2);
+x_79 = lean_ctor_get(x_6, 3);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_inc(x_77);
+lean_inc(x_76);
+lean_dec(x_6);
+x_80 = 1;
+x_81 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_81, 0, x_76);
+lean_ctor_set(x_81, 1, x_77);
+lean_ctor_set(x_81, 2, x_78);
+lean_ctor_set(x_81, 3, x_79);
+lean_ctor_set_uint8(x_81, sizeof(void*)*4, x_80);
+lean_ctor_set(x_4, 3, x_3);
+lean_ctor_set(x_4, 2, x_2);
+lean_ctor_set(x_4, 1, x_1);
+lean_ctor_set(x_4, 0, x_70);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_80);
+x_82 = 0;
+x_83 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_83, 0, x_81);
+lean_ctor_set(x_83, 1, x_68);
+lean_ctor_set(x_83, 2, x_69);
+lean_ctor_set(x_83, 3, x_4);
+lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_82);
+return x_83;
+}
+}
+else
+{
+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; uint8_t x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; lean_object* x_96; 
+x_84 = lean_ctor_get(x_4, 1);
+x_85 = lean_ctor_get(x_4, 2);
+x_86 = lean_ctor_get(x_4, 3);
+lean_inc(x_86);
+lean_inc(x_85);
+lean_inc(x_84);
+lean_dec(x_4);
+x_87 = lean_ctor_get(x_6, 0);
+lean_inc(x_87);
+x_88 = lean_ctor_get(x_6, 1);
+lean_inc(x_88);
+x_89 = lean_ctor_get(x_6, 2);
+lean_inc(x_89);
+x_90 = lean_ctor_get(x_6, 3);
+lean_inc(x_90);
 if (lean_is_exclusive(x_6)) {
  lean_ctor_release(x_6, 0);
  lean_ctor_release(x_6, 1);
  lean_ctor_release(x_6, 2);
  lean_ctor_release(x_6, 3);
- x_45 = x_6;
+ x_91 = x_6;
 } else {
  lean_dec_ref(x_6);
- x_45 = lean_box(0);
+ x_91 = lean_box(0);
 }
-x_46 = 1;
-if (lean_is_scalar(x_45)) {
- x_47 = lean_alloc_ctor(1, 4, 1);
+x_92 = 1;
+if (lean_is_scalar(x_91)) {
+ x_93 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_47 = x_45;
+ x_93 = x_91;
 }
-lean_ctor_set(x_47, 0, x_5);
-lean_ctor_set(x_47, 1, x_39);
-lean_ctor_set(x_47, 2, x_40);
-lean_ctor_set(x_47, 3, x_41);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_48, 0, x_44);
-lean_ctor_set(x_48, 1, x_1);
-lean_ctor_set(x_48, 2, x_2);
-lean_ctor_set(x_48, 3, x_3);
-lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_46);
-x_49 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_49, 0, x_47);
-lean_ctor_set(x_49, 1, x_42);
-lean_ctor_set(x_49, 2, x_43);
-lean_ctor_set(x_49, 3, x_48);
-lean_ctor_set_uint8(x_49, sizeof(void*)*4, x_19);
-return x_49;
+lean_ctor_set(x_93, 0, x_87);
+lean_ctor_set(x_93, 1, x_88);
+lean_ctor_set(x_93, 2, x_89);
+lean_ctor_set(x_93, 3, x_90);
+lean_ctor_set_uint8(x_93, sizeof(void*)*4, x_92);
+x_94 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_94, 0, x_86);
+lean_ctor_set(x_94, 1, x_1);
+lean_ctor_set(x_94, 2, x_2);
+lean_ctor_set(x_94, 3, x_3);
+lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_92);
+x_95 = 0;
+x_96 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_96, 0, x_93);
+lean_ctor_set(x_96, 1, x_84);
+lean_ctor_set(x_96, 2, x_85);
+lean_ctor_set(x_96, 3, x_94);
+lean_ctor_set_uint8(x_96, sizeof(void*)*4, x_95);
+return x_96;
 }
 }
 else
 {
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_4);
-if (x_50 == 0)
+lean_object* x_97; 
+x_97 = lean_ctor_get(x_4, 3);
+lean_inc(x_97);
+if (lean_obj_tag(x_97) == 0)
 {
-lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; 
-x_51 = lean_ctor_get(x_4, 3);
-lean_dec(x_51);
-x_52 = lean_ctor_get(x_4, 0);
-lean_dec(x_52);
-x_53 = 0;
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_53);
-x_54 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_54, 0, x_4);
-lean_ctor_set(x_54, 1, x_1);
-lean_ctor_set(x_54, 2, x_2);
-lean_ctor_set(x_54, 3, x_3);
-lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_19);
-return x_54;
+uint8_t x_98; 
+x_98 = !lean_is_exclusive(x_4);
+if (x_98 == 0)
+{
+lean_object* x_99; lean_object* x_100; uint8_t x_101; uint8_t x_102; lean_object* x_103; 
+x_99 = lean_ctor_get(x_4, 3);
+lean_dec(x_99);
+x_100 = lean_ctor_get(x_4, 0);
+lean_dec(x_100);
+x_101 = 0;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_101);
+x_102 = 1;
+x_103 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_103, 0, x_4);
+lean_ctor_set(x_103, 1, x_1);
+lean_ctor_set(x_103, 2, x_2);
+lean_ctor_set(x_103, 3, x_3);
+lean_ctor_set_uint8(x_103, sizeof(void*)*4, x_102);
+return x_103;
 }
 else
 {
-lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; 
-x_55 = lean_ctor_get(x_4, 1);
-x_56 = lean_ctor_get(x_4, 2);
-lean_inc(x_56);
-lean_inc(x_55);
+lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; 
+x_104 = lean_ctor_get(x_4, 1);
+x_105 = lean_ctor_get(x_4, 2);
+lean_inc(x_105);
+lean_inc(x_104);
 lean_dec(x_4);
-x_57 = 0;
-x_58 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_58, 0, x_5);
-lean_ctor_set(x_58, 1, x_55);
-lean_ctor_set(x_58, 2, x_56);
-lean_ctor_set(x_58, 3, x_6);
-lean_ctor_set_uint8(x_58, sizeof(void*)*4, x_57);
-x_59 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_59, 0, x_58);
-lean_ctor_set(x_59, 1, x_1);
-lean_ctor_set(x_59, 2, x_2);
-lean_ctor_set(x_59, 3, x_3);
-lean_ctor_set_uint8(x_59, sizeof(void*)*4, x_19);
-return x_59;
-}
-}
+x_106 = 0;
+x_107 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_107, 0, x_6);
+lean_ctor_set(x_107, 1, x_104);
+lean_ctor_set(x_107, 2, x_105);
+lean_ctor_set(x_107, 3, x_97);
+lean_ctor_set_uint8(x_107, sizeof(void*)*4, x_106);
+x_108 = 1;
+x_109 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_109, 0, x_107);
+lean_ctor_set(x_109, 1, x_1);
+lean_ctor_set(x_109, 2, x_2);
+lean_ctor_set(x_109, 3, x_3);
+lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
+return x_109;
 }
 }
 else
 {
-uint8_t x_60; 
-x_60 = lean_ctor_get_uint8(x_5, sizeof(void*)*4);
-if (x_60 == 0)
-{
-uint8_t x_61; 
-x_61 = !lean_is_exclusive(x_4);
-if (x_61 == 0)
-{
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; 
-x_62 = lean_ctor_get(x_4, 1);
-x_63 = lean_ctor_get(x_4, 2);
-x_64 = lean_ctor_get(x_4, 3);
-x_65 = lean_ctor_get(x_4, 0);
-lean_dec(x_65);
-x_66 = !lean_is_exclusive(x_5);
-if (x_66 == 0)
-{
-uint8_t x_67; lean_object* x_68; 
-x_67 = 1;
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_67);
-lean_ctor_set(x_4, 3, x_3);
-lean_ctor_set(x_4, 2, x_2);
-lean_ctor_set(x_4, 1, x_1);
-lean_ctor_set(x_4, 0, x_64);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_67);
-x_68 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_68, 0, x_5);
-lean_ctor_set(x_68, 1, x_62);
-lean_ctor_set(x_68, 2, x_63);
-lean_ctor_set(x_68, 3, x_4);
-lean_ctor_set_uint8(x_68, sizeof(void*)*4, x_60);
-return x_68;
-}
-else
-{
-lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; 
-x_69 = lean_ctor_get(x_5, 0);
-x_70 = lean_ctor_get(x_5, 1);
-x_71 = lean_ctor_get(x_5, 2);
-x_72 = lean_ctor_get(x_5, 3);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_inc(x_70);
-lean_inc(x_69);
-lean_dec(x_5);
-x_73 = 1;
-x_74 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_74, 0, x_69);
-lean_ctor_set(x_74, 1, x_70);
-lean_ctor_set(x_74, 2, x_71);
-lean_ctor_set(x_74, 3, x_72);
-lean_ctor_set_uint8(x_74, sizeof(void*)*4, x_73);
-lean_ctor_set(x_4, 3, x_3);
-lean_ctor_set(x_4, 2, x_2);
-lean_ctor_set(x_4, 1, x_1);
-lean_ctor_set(x_4, 0, x_64);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_73);
-x_75 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_62);
-lean_ctor_set(x_75, 2, x_63);
-lean_ctor_set(x_75, 3, x_4);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_60);
-return x_75;
-}
-}
-else
-{
-lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; uint8_t x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; 
-x_76 = lean_ctor_get(x_4, 1);
-x_77 = lean_ctor_get(x_4, 2);
-x_78 = lean_ctor_get(x_4, 3);
-lean_inc(x_78);
-lean_inc(x_77);
-lean_inc(x_76);
-lean_dec(x_4);
-x_79 = lean_ctor_get(x_5, 0);
-lean_inc(x_79);
-x_80 = lean_ctor_get(x_5, 1);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_5, 2);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_5, 3);
-lean_inc(x_82);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_83 = x_5;
-} else {
- lean_dec_ref(x_5);
- x_83 = lean_box(0);
-}
-x_84 = 1;
-if (lean_is_scalar(x_83)) {
- x_85 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_85 = x_83;
-}
-lean_ctor_set(x_85, 0, x_79);
-lean_ctor_set(x_85, 1, x_80);
-lean_ctor_set(x_85, 2, x_81);
-lean_ctor_set(x_85, 3, x_82);
-lean_ctor_set_uint8(x_85, sizeof(void*)*4, x_84);
-x_86 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_86, 0, x_78);
-lean_ctor_set(x_86, 1, x_1);
-lean_ctor_set(x_86, 2, x_2);
-lean_ctor_set(x_86, 3, x_3);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_84);
-x_87 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_87, 0, x_85);
-lean_ctor_set(x_87, 1, x_76);
-lean_ctor_set(x_87, 2, x_77);
-lean_ctor_set(x_87, 3, x_86);
-lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_60);
-return x_87;
-}
-}
-else
-{
-lean_object* x_88; 
-x_88 = lean_ctor_get(x_4, 3);
-lean_inc(x_88);
-if (lean_obj_tag(x_88) == 0)
-{
-uint8_t x_89; 
-x_89 = !lean_is_exclusive(x_4);
-if (x_89 == 0)
-{
-lean_object* x_90; lean_object* x_91; uint8_t x_92; lean_object* x_93; 
-x_90 = lean_ctor_get(x_4, 3);
-lean_dec(x_90);
-x_91 = lean_ctor_get(x_4, 0);
-lean_dec(x_91);
-x_92 = 0;
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_92);
-x_93 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_93, 0, x_4);
-lean_ctor_set(x_93, 1, x_1);
-lean_ctor_set(x_93, 2, x_2);
-lean_ctor_set(x_93, 3, x_3);
-lean_ctor_set_uint8(x_93, sizeof(void*)*4, x_60);
-return x_93;
-}
-else
-{
-lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; lean_object* x_98; 
-x_94 = lean_ctor_get(x_4, 1);
-x_95 = lean_ctor_get(x_4, 2);
-lean_inc(x_95);
-lean_inc(x_94);
-lean_dec(x_4);
-x_96 = 0;
-x_97 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_97, 0, x_5);
-lean_ctor_set(x_97, 1, x_94);
-lean_ctor_set(x_97, 2, x_95);
-lean_ctor_set(x_97, 3, x_88);
-lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
-x_98 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_98, 0, x_97);
-lean_ctor_set(x_98, 1, x_1);
-lean_ctor_set(x_98, 2, x_2);
-lean_ctor_set(x_98, 3, x_3);
-lean_ctor_set_uint8(x_98, sizeof(void*)*4, x_60);
-return x_98;
-}
-}
-else
-{
-uint8_t x_99; 
-x_99 = lean_ctor_get_uint8(x_88, sizeof(void*)*4);
-if (x_99 == 0)
-{
-uint8_t x_100; 
-x_100 = !lean_is_exclusive(x_4);
-if (x_100 == 0)
-{
-lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; uint8_t x_105; 
-x_101 = lean_ctor_get(x_4, 1);
-x_102 = lean_ctor_get(x_4, 2);
-x_103 = lean_ctor_get(x_4, 3);
-lean_dec(x_103);
-x_104 = lean_ctor_get(x_4, 0);
-lean_dec(x_104);
-x_105 = !lean_is_exclusive(x_88);
-if (x_105 == 0)
-{
-lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; uint8_t x_110; 
-x_106 = lean_ctor_get(x_88, 0);
-x_107 = lean_ctor_get(x_88, 1);
-x_108 = lean_ctor_get(x_88, 2);
-x_109 = lean_ctor_get(x_88, 3);
-lean_inc(x_5);
-lean_ctor_set(x_88, 3, x_106);
-lean_ctor_set(x_88, 2, x_102);
-lean_ctor_set(x_88, 1, x_101);
-lean_ctor_set(x_88, 0, x_5);
-x_110 = !lean_is_exclusive(x_5);
+uint8_t x_110; 
+x_110 = lean_ctor_get_uint8(x_97, sizeof(void*)*4);
 if (x_110 == 0)
 {
-lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; 
-x_111 = lean_ctor_get(x_5, 3);
-lean_dec(x_111);
-x_112 = lean_ctor_get(x_5, 2);
-lean_dec(x_112);
-x_113 = lean_ctor_get(x_5, 1);
-lean_dec(x_113);
-x_114 = lean_ctor_get(x_5, 0);
+uint8_t x_111; 
+x_111 = !lean_is_exclusive(x_4);
+if (x_111 == 0)
+{
+lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; 
+x_112 = lean_ctor_get(x_4, 1);
+x_113 = lean_ctor_get(x_4, 2);
+x_114 = lean_ctor_get(x_4, 3);
 lean_dec(x_114);
-lean_ctor_set_uint8(x_88, sizeof(void*)*4, x_60);
-lean_ctor_set(x_5, 3, x_3);
-lean_ctor_set(x_5, 2, x_2);
-lean_ctor_set(x_5, 1, x_1);
-lean_ctor_set(x_5, 0, x_109);
-lean_ctor_set(x_4, 3, x_5);
-lean_ctor_set(x_4, 2, x_108);
-lean_ctor_set(x_4, 1, x_107);
-lean_ctor_set(x_4, 0, x_88);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_99);
+x_115 = lean_ctor_get(x_4, 0);
+lean_dec(x_115);
+x_116 = !lean_is_exclusive(x_97);
+if (x_116 == 0)
+{
+lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; uint8_t x_121; uint8_t x_122; 
+x_117 = lean_ctor_get(x_97, 0);
+x_118 = lean_ctor_get(x_97, 1);
+x_119 = lean_ctor_get(x_97, 2);
+x_120 = lean_ctor_get(x_97, 3);
+x_121 = 1;
+lean_inc(x_6);
+lean_ctor_set(x_97, 3, x_117);
+lean_ctor_set(x_97, 2, x_113);
+lean_ctor_set(x_97, 1, x_112);
+lean_ctor_set(x_97, 0, x_6);
+x_122 = !lean_is_exclusive(x_6);
+if (x_122 == 0)
+{
+lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; uint8_t x_127; 
+x_123 = lean_ctor_get(x_6, 3);
+lean_dec(x_123);
+x_124 = lean_ctor_get(x_6, 2);
+lean_dec(x_124);
+x_125 = lean_ctor_get(x_6, 1);
+lean_dec(x_125);
+x_126 = lean_ctor_get(x_6, 0);
+lean_dec(x_126);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_121);
+lean_ctor_set(x_6, 3, x_3);
+lean_ctor_set(x_6, 2, x_2);
+lean_ctor_set(x_6, 1, x_1);
+lean_ctor_set(x_6, 0, x_120);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_121);
+x_127 = 0;
+lean_ctor_set(x_4, 3, x_6);
+lean_ctor_set(x_4, 2, x_119);
+lean_ctor_set(x_4, 1, x_118);
+lean_ctor_set(x_4, 0, x_97);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_127);
 return x_4;
 }
 else
 {
-lean_object* x_115; 
-lean_dec(x_5);
-lean_ctor_set_uint8(x_88, sizeof(void*)*4, x_60);
-x_115 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_115, 0, x_109);
-lean_ctor_set(x_115, 1, x_1);
-lean_ctor_set(x_115, 2, x_2);
-lean_ctor_set(x_115, 3, x_3);
-lean_ctor_set_uint8(x_115, sizeof(void*)*4, x_60);
-lean_ctor_set(x_4, 3, x_115);
-lean_ctor_set(x_4, 2, x_108);
-lean_ctor_set(x_4, 1, x_107);
-lean_ctor_set(x_4, 0, x_88);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_99);
+lean_object* x_128; uint8_t x_129; 
+lean_dec(x_6);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_121);
+x_128 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_128, 0, x_120);
+lean_ctor_set(x_128, 1, x_1);
+lean_ctor_set(x_128, 2, x_2);
+lean_ctor_set(x_128, 3, x_3);
+lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_121);
+x_129 = 0;
+lean_ctor_set(x_4, 3, x_128);
+lean_ctor_set(x_4, 2, x_119);
+lean_ctor_set(x_4, 1, x_118);
+lean_ctor_set(x_4, 0, x_97);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_129);
 return x_4;
 }
 }
 else
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; 
-x_116 = lean_ctor_get(x_88, 0);
-x_117 = lean_ctor_get(x_88, 1);
-x_118 = lean_ctor_get(x_88, 2);
-x_119 = lean_ctor_get(x_88, 3);
-lean_inc(x_119);
-lean_inc(x_118);
-lean_inc(x_117);
-lean_inc(x_116);
-lean_dec(x_88);
-lean_inc(x_5);
-x_120 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_120, 0, x_5);
-lean_ctor_set(x_120, 1, x_101);
-lean_ctor_set(x_120, 2, x_102);
-lean_ctor_set(x_120, 3, x_116);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_121 = x_5;
+lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; uint8_t x_138; 
+x_130 = lean_ctor_get(x_97, 0);
+x_131 = lean_ctor_get(x_97, 1);
+x_132 = lean_ctor_get(x_97, 2);
+x_133 = lean_ctor_get(x_97, 3);
+lean_inc(x_133);
+lean_inc(x_132);
+lean_inc(x_131);
+lean_inc(x_130);
+lean_dec(x_97);
+x_134 = 1;
+lean_inc(x_6);
+x_135 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_135, 0, x_6);
+lean_ctor_set(x_135, 1, x_112);
+lean_ctor_set(x_135, 2, x_113);
+lean_ctor_set(x_135, 3, x_130);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ lean_ctor_release(x_6, 2);
+ lean_ctor_release(x_6, 3);
+ x_136 = x_6;
 } else {
- lean_dec_ref(x_5);
- x_121 = lean_box(0);
+ lean_dec_ref(x_6);
+ x_136 = lean_box(0);
 }
-lean_ctor_set_uint8(x_120, sizeof(void*)*4, x_60);
-if (lean_is_scalar(x_121)) {
- x_122 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set_uint8(x_135, sizeof(void*)*4, x_134);
+if (lean_is_scalar(x_136)) {
+ x_137 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_122 = x_121;
+ x_137 = x_136;
 }
-lean_ctor_set(x_122, 0, x_119);
-lean_ctor_set(x_122, 1, x_1);
-lean_ctor_set(x_122, 2, x_2);
-lean_ctor_set(x_122, 3, x_3);
-lean_ctor_set_uint8(x_122, sizeof(void*)*4, x_60);
-lean_ctor_set(x_4, 3, x_122);
-lean_ctor_set(x_4, 2, x_118);
-lean_ctor_set(x_4, 1, x_117);
-lean_ctor_set(x_4, 0, x_120);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_99);
-return x_4;
-}
-}
-else
-{
-lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; 
-x_123 = lean_ctor_get(x_4, 1);
-x_124 = lean_ctor_get(x_4, 2);
-lean_inc(x_124);
-lean_inc(x_123);
-lean_dec(x_4);
-x_125 = lean_ctor_get(x_88, 0);
-lean_inc(x_125);
-x_126 = lean_ctor_get(x_88, 1);
-lean_inc(x_126);
-x_127 = lean_ctor_get(x_88, 2);
-lean_inc(x_127);
-x_128 = lean_ctor_get(x_88, 3);
-lean_inc(x_128);
-if (lean_is_exclusive(x_88)) {
- lean_ctor_release(x_88, 0);
- lean_ctor_release(x_88, 1);
- lean_ctor_release(x_88, 2);
- lean_ctor_release(x_88, 3);
- x_129 = x_88;
-} else {
- lean_dec_ref(x_88);
- x_129 = lean_box(0);
-}
-lean_inc(x_5);
-if (lean_is_scalar(x_129)) {
- x_130 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_130 = x_129;
-}
-lean_ctor_set(x_130, 0, x_5);
-lean_ctor_set(x_130, 1, x_123);
-lean_ctor_set(x_130, 2, x_124);
-lean_ctor_set(x_130, 3, x_125);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_131 = x_5;
-} else {
- lean_dec_ref(x_5);
- x_131 = lean_box(0);
-}
-lean_ctor_set_uint8(x_130, sizeof(void*)*4, x_60);
-if (lean_is_scalar(x_131)) {
- x_132 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_132 = x_131;
-}
-lean_ctor_set(x_132, 0, x_128);
-lean_ctor_set(x_132, 1, x_1);
-lean_ctor_set(x_132, 2, x_2);
-lean_ctor_set(x_132, 3, x_3);
-lean_ctor_set_uint8(x_132, sizeof(void*)*4, x_60);
-x_133 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_133, 0, x_130);
-lean_ctor_set(x_133, 1, x_126);
-lean_ctor_set(x_133, 2, x_127);
-lean_ctor_set(x_133, 3, x_132);
-lean_ctor_set_uint8(x_133, sizeof(void*)*4, x_99);
-return x_133;
-}
-}
-else
-{
-uint8_t x_134; 
-x_134 = !lean_is_exclusive(x_4);
-if (x_134 == 0)
-{
-lean_object* x_135; lean_object* x_136; uint8_t x_137; 
-x_135 = lean_ctor_get(x_4, 3);
-lean_dec(x_135);
-x_136 = lean_ctor_get(x_4, 0);
-lean_dec(x_136);
-x_137 = !lean_is_exclusive(x_5);
-if (x_137 == 0)
-{
-uint8_t x_138; lean_object* x_139; 
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_99);
+lean_ctor_set(x_137, 0, x_133);
+lean_ctor_set(x_137, 1, x_1);
+lean_ctor_set(x_137, 2, x_2);
+lean_ctor_set(x_137, 3, x_3);
+lean_ctor_set_uint8(x_137, sizeof(void*)*4, x_134);
 x_138 = 0;
+lean_ctor_set(x_4, 3, x_137);
+lean_ctor_set(x_4, 2, x_132);
+lean_ctor_set(x_4, 1, x_131);
+lean_ctor_set(x_4, 0, x_135);
 lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_138);
-x_139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_139, 0, x_4);
-lean_ctor_set(x_139, 1, x_1);
-lean_ctor_set(x_139, 2, x_2);
-lean_ctor_set(x_139, 3, x_3);
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_99);
-return x_139;
+return x_4;
+}
 }
 else
 {
-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_146; 
-x_140 = lean_ctor_get(x_5, 0);
-x_141 = lean_ctor_get(x_5, 1);
-x_142 = lean_ctor_get(x_5, 2);
-x_143 = lean_ctor_get(x_5, 3);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_inc(x_141);
+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_object* x_147; lean_object* x_148; lean_object* x_149; uint8_t x_150; lean_object* x_151; 
+x_139 = lean_ctor_get(x_4, 1);
+x_140 = lean_ctor_get(x_4, 2);
 lean_inc(x_140);
-lean_dec(x_5);
-x_144 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_144, 0, x_140);
-lean_ctor_set(x_144, 1, x_141);
-lean_ctor_set(x_144, 2, x_142);
-lean_ctor_set(x_144, 3, x_143);
-lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_99);
-x_145 = 0;
-lean_ctor_set(x_4, 0, x_144);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_145);
-x_146 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_146, 0, x_4);
-lean_ctor_set(x_146, 1, x_1);
-lean_ctor_set(x_146, 2, x_2);
-lean_ctor_set(x_146, 3, x_3);
-lean_ctor_set_uint8(x_146, sizeof(void*)*4, x_99);
-return x_146;
+lean_inc(x_139);
+lean_dec(x_4);
+x_141 = lean_ctor_get(x_97, 0);
+lean_inc(x_141);
+x_142 = lean_ctor_get(x_97, 1);
+lean_inc(x_142);
+x_143 = lean_ctor_get(x_97, 2);
+lean_inc(x_143);
+x_144 = lean_ctor_get(x_97, 3);
+lean_inc(x_144);
+if (lean_is_exclusive(x_97)) {
+ lean_ctor_release(x_97, 0);
+ lean_ctor_release(x_97, 1);
+ lean_ctor_release(x_97, 2);
+ lean_ctor_release(x_97, 3);
+ x_145 = x_97;
+} else {
+ lean_dec_ref(x_97);
+ x_145 = lean_box(0);
+}
+x_146 = 1;
+lean_inc(x_6);
+if (lean_is_scalar(x_145)) {
+ x_147 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_147 = x_145;
+}
+lean_ctor_set(x_147, 0, x_6);
+lean_ctor_set(x_147, 1, x_139);
+lean_ctor_set(x_147, 2, x_140);
+lean_ctor_set(x_147, 3, x_141);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ lean_ctor_release(x_6, 2);
+ lean_ctor_release(x_6, 3);
+ x_148 = x_6;
+} else {
+ lean_dec_ref(x_6);
+ x_148 = lean_box(0);
+}
+lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_146);
+if (lean_is_scalar(x_148)) {
+ x_149 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_149 = x_148;
+}
+lean_ctor_set(x_149, 0, x_144);
+lean_ctor_set(x_149, 1, x_1);
+lean_ctor_set(x_149, 2, x_2);
+lean_ctor_set(x_149, 3, x_3);
+lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_146);
+x_150 = 0;
+x_151 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_151, 0, x_147);
+lean_ctor_set(x_151, 1, x_142);
+lean_ctor_set(x_151, 2, x_143);
+lean_ctor_set(x_151, 3, x_149);
+lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_150);
+return x_151;
 }
 }
 else
 {
-lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; lean_object* x_156; lean_object* x_157; 
-x_147 = lean_ctor_get(x_4, 1);
-x_148 = lean_ctor_get(x_4, 2);
-lean_inc(x_148);
-lean_inc(x_147);
+uint8_t x_152; 
+x_152 = !lean_is_exclusive(x_4);
+if (x_152 == 0)
+{
+lean_object* x_153; lean_object* x_154; uint8_t x_155; 
+x_153 = lean_ctor_get(x_4, 3);
+lean_dec(x_153);
+x_154 = lean_ctor_get(x_4, 0);
+lean_dec(x_154);
+x_155 = !lean_is_exclusive(x_6);
+if (x_155 == 0)
+{
+uint8_t x_156; uint8_t x_157; lean_object* x_158; 
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_110);
+x_156 = 0;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_156);
+x_157 = 1;
+x_158 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_158, 0, x_4);
+lean_ctor_set(x_158, 1, x_1);
+lean_ctor_set(x_158, 2, x_2);
+lean_ctor_set(x_158, 3, x_3);
+lean_ctor_set_uint8(x_158, sizeof(void*)*4, x_157);
+return x_158;
+}
+else
+{
+lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; uint8_t x_164; uint8_t x_165; lean_object* x_166; 
+x_159 = lean_ctor_get(x_6, 0);
+x_160 = lean_ctor_get(x_6, 1);
+x_161 = lean_ctor_get(x_6, 2);
+x_162 = lean_ctor_get(x_6, 3);
+lean_inc(x_162);
+lean_inc(x_161);
+lean_inc(x_160);
+lean_inc(x_159);
+lean_dec(x_6);
+x_163 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_163, 0, x_159);
+lean_ctor_set(x_163, 1, x_160);
+lean_ctor_set(x_163, 2, x_161);
+lean_ctor_set(x_163, 3, x_162);
+lean_ctor_set_uint8(x_163, sizeof(void*)*4, x_110);
+x_164 = 0;
+lean_ctor_set(x_4, 0, x_163);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_164);
+x_165 = 1;
+x_166 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_166, 0, x_4);
+lean_ctor_set(x_166, 1, x_1);
+lean_ctor_set(x_166, 2, x_2);
+lean_ctor_set(x_166, 3, x_3);
+lean_ctor_set_uint8(x_166, sizeof(void*)*4, x_165);
+return x_166;
+}
+}
+else
+{
+lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; lean_object* x_176; uint8_t x_177; lean_object* x_178; 
+x_167 = lean_ctor_get(x_4, 1);
+x_168 = lean_ctor_get(x_4, 2);
+lean_inc(x_168);
+lean_inc(x_167);
 lean_dec(x_4);
-x_149 = lean_ctor_get(x_5, 0);
-lean_inc(x_149);
-x_150 = lean_ctor_get(x_5, 1);
-lean_inc(x_150);
-x_151 = lean_ctor_get(x_5, 2);
-lean_inc(x_151);
-x_152 = lean_ctor_get(x_5, 3);
-lean_inc(x_152);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_153 = x_5;
+x_169 = lean_ctor_get(x_6, 0);
+lean_inc(x_169);
+x_170 = lean_ctor_get(x_6, 1);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_6, 2);
+lean_inc(x_171);
+x_172 = lean_ctor_get(x_6, 3);
+lean_inc(x_172);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ lean_ctor_release(x_6, 2);
+ lean_ctor_release(x_6, 3);
+ x_173 = x_6;
 } else {
- lean_dec_ref(x_5);
- x_153 = lean_box(0);
+ lean_dec_ref(x_6);
+ x_173 = lean_box(0);
 }
-if (lean_is_scalar(x_153)) {
- x_154 = lean_alloc_ctor(1, 4, 1);
+if (lean_is_scalar(x_173)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_154 = x_153;
+ x_174 = x_173;
 }
-lean_ctor_set(x_154, 0, x_149);
-lean_ctor_set(x_154, 1, x_150);
-lean_ctor_set(x_154, 2, x_151);
-lean_ctor_set(x_154, 3, x_152);
-lean_ctor_set_uint8(x_154, sizeof(void*)*4, x_99);
-x_155 = 0;
-x_156 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_156, 0, x_154);
-lean_ctor_set(x_156, 1, x_147);
-lean_ctor_set(x_156, 2, x_148);
-lean_ctor_set(x_156, 3, x_88);
-lean_ctor_set_uint8(x_156, sizeof(void*)*4, x_155);
-x_157 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_157, 0, x_156);
-lean_ctor_set(x_157, 1, x_1);
-lean_ctor_set(x_157, 2, x_2);
-lean_ctor_set(x_157, 3, x_3);
-lean_ctor_set_uint8(x_157, sizeof(void*)*4, x_99);
-return x_157;
+lean_ctor_set(x_174, 0, x_169);
+lean_ctor_set(x_174, 1, x_170);
+lean_ctor_set(x_174, 2, x_171);
+lean_ctor_set(x_174, 3, x_172);
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_110);
+x_175 = 0;
+x_176 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_176, 0, x_174);
+lean_ctor_set(x_176, 1, x_167);
+lean_ctor_set(x_176, 2, x_168);
+lean_ctor_set(x_176, 3, x_97);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_175);
+x_177 = 1;
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_176);
+lean_ctor_set(x_178, 1, x_1);
+lean_ctor_set(x_178, 2, x_2);
+lean_ctor_set(x_178, 3, x_3);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+return x_178;
 }
 }
 }
@@ -1604,705 +2099,942 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_balance1___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_balance2_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+if (lean_obj_tag(x_4) == 0)
+{
+lean_object* x_9; 
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+x_9 = lean_apply_4(x_8, x_1, x_2, x_3, x_4);
+return x_9;
+}
+else
+{
+lean_object* x_10; 
+lean_dec(x_8);
+x_10 = lean_ctor_get(x_4, 0);
+lean_inc(x_10);
+if (lean_obj_tag(x_10) == 0)
+{
+lean_object* x_11; 
+lean_dec(x_5);
+x_11 = lean_ctor_get(x_4, 3);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+lean_dec(x_6);
+x_12 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_13 = lean_ctor_get(x_4, 1);
+lean_inc(x_13);
+x_14 = lean_ctor_get(x_4, 2);
+lean_inc(x_14);
+lean_dec(x_4);
+x_15 = lean_box(x_12);
+x_16 = lean_apply_8(x_7, x_1, x_2, x_3, x_15, x_11, x_13, x_14, x_11);
+return x_16;
+}
+else
+{
+uint8_t x_17; 
+x_17 = lean_ctor_get_uint8(x_11, sizeof(void*)*4);
+if (x_17 == 0)
+{
+uint8_t 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_dec(x_7);
+x_18 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_19 = lean_ctor_get(x_4, 1);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_4, 2);
+lean_inc(x_20);
+lean_dec(x_4);
+x_21 = lean_ctor_get(x_11, 0);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_11, 1);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_11, 2);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_11, 3);
+lean_inc(x_24);
+lean_dec(x_11);
+x_25 = lean_box(x_18);
+x_26 = lean_apply_11(x_6, x_1, x_2, x_3, x_25, x_10, x_19, x_20, x_21, x_22, x_23, x_24);
+return x_26;
+}
+else
+{
+uint8_t x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; 
+lean_dec(x_6);
+x_27 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_28 = lean_ctor_get(x_4, 1);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_4, 2);
+lean_inc(x_29);
+lean_dec(x_4);
+x_30 = lean_box(x_27);
+x_31 = lean_apply_8(x_7, x_1, x_2, x_3, x_30, x_10, x_28, x_29, x_11);
+return x_31;
+}
+}
+}
+else
+{
+uint8_t x_32; 
+x_32 = lean_ctor_get_uint8(x_10, sizeof(void*)*4);
+if (x_32 == 0)
+{
+uint8_t 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_dec(x_7);
+lean_dec(x_6);
+x_33 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_34 = lean_ctor_get(x_4, 1);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_4, 2);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_4, 3);
+lean_inc(x_36);
+lean_dec(x_4);
+x_37 = lean_ctor_get(x_10, 0);
+lean_inc(x_37);
+x_38 = lean_ctor_get(x_10, 1);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_10, 2);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_10, 3);
+lean_inc(x_40);
+lean_dec(x_10);
+x_41 = lean_box(x_33);
+x_42 = lean_apply_11(x_5, x_1, x_2, x_3, x_41, x_37, x_38, x_39, x_40, x_34, x_35, x_36);
+return x_42;
+}
+else
+{
+lean_object* x_43; 
+lean_dec(x_5);
+x_43 = lean_ctor_get(x_4, 3);
+lean_inc(x_43);
+if (lean_obj_tag(x_43) == 0)
+{
+uint8_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; 
+lean_dec(x_6);
+x_44 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_45 = lean_ctor_get(x_4, 1);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_4, 2);
+lean_inc(x_46);
+lean_dec(x_4);
+x_47 = lean_box(x_44);
+x_48 = lean_apply_8(x_7, x_1, x_2, x_3, x_47, x_10, x_45, x_46, x_43);
+return x_48;
+}
+else
+{
+uint8_t x_49; 
+x_49 = lean_ctor_get_uint8(x_43, sizeof(void*)*4);
+if (x_49 == 0)
+{
+uint8_t 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_dec(x_7);
+x_50 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_51 = lean_ctor_get(x_4, 1);
+lean_inc(x_51);
+x_52 = lean_ctor_get(x_4, 2);
+lean_inc(x_52);
+lean_dec(x_4);
+x_53 = lean_ctor_get(x_43, 0);
+lean_inc(x_53);
+x_54 = lean_ctor_get(x_43, 1);
+lean_inc(x_54);
+x_55 = lean_ctor_get(x_43, 2);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_43, 3);
+lean_inc(x_56);
+lean_dec(x_43);
+x_57 = lean_box(x_50);
+x_58 = lean_apply_11(x_6, x_1, x_2, x_3, x_57, x_10, x_51, x_52, x_53, x_54, x_55, x_56);
+return x_58;
+}
+else
+{
+uint8_t x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; 
+lean_dec(x_6);
+x_59 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+x_60 = lean_ctor_get(x_4, 1);
+lean_inc(x_60);
+x_61 = lean_ctor_get(x_4, 2);
+lean_inc(x_61);
+lean_dec(x_4);
+x_62 = !lean_is_exclusive(x_10);
+if (x_62 == 0)
+{
+lean_object* x_63; lean_object* x_64; 
+lean_ctor_set_uint8(x_10, sizeof(void*)*4, x_49);
+x_63 = lean_box(x_59);
+x_64 = lean_apply_8(x_7, x_1, x_2, x_3, x_63, x_10, x_60, x_61, x_43);
+return x_64;
+}
+else
+{
+lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; 
+x_65 = lean_ctor_get(x_10, 0);
+x_66 = lean_ctor_get(x_10, 1);
+x_67 = lean_ctor_get(x_10, 2);
+x_68 = lean_ctor_get(x_10, 3);
+lean_inc(x_68);
+lean_inc(x_67);
+lean_inc(x_66);
+lean_inc(x_65);
+lean_dec(x_10);
+x_69 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_69, 0, x_65);
+lean_ctor_set(x_69, 1, x_66);
+lean_ctor_set(x_69, 2, x_67);
+lean_ctor_set(x_69, 3, x_68);
+lean_ctor_set_uint8(x_69, sizeof(void*)*4, x_49);
+x_70 = lean_box(x_59);
+x_71 = lean_apply_8(x_7, x_1, x_2, x_3, x_70, x_69, x_60, x_61, x_43);
+return x_71;
+}
+}
+}
+}
+}
+}
+}
+}
+lean_object* l_Std_RBNode_balance2_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_balance2_match__1___rarg), 8, 0);
+return x_4;
+}
+}
 lean_object* l_Std_RBNode_balance2___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_object* x_5; 
 lean_dec(x_3);
 lean_dec(x_2);
 lean_dec(x_1);
-return x_4;
+x_5 = lean_box(0);
+return x_5;
 }
 else
 {
-lean_object* x_5; 
-x_5 = lean_ctor_get(x_4, 0);
-lean_inc(x_5);
-if (lean_obj_tag(x_5) == 0)
-{
 lean_object* x_6; 
-x_6 = lean_ctor_get(x_4, 3);
+x_6 = lean_ctor_get(x_4, 0);
 lean_inc(x_6);
 if (lean_obj_tag(x_6) == 0)
 {
-uint8_t x_7; 
-x_7 = !lean_is_exclusive(x_4);
-if (x_7 == 0)
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_4, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
 {
-lean_object* x_8; lean_object* x_9; uint8_t x_10; uint8_t x_11; lean_object* x_12; 
-x_8 = lean_ctor_get(x_4, 3);
-lean_dec(x_8);
-x_9 = lean_ctor_get(x_4, 0);
+uint8_t x_8; 
+x_8 = !lean_is_exclusive(x_4);
+if (x_8 == 0)
+{
+lean_object* x_9; lean_object* x_10; uint8_t x_11; uint8_t x_12; lean_object* x_13; 
+x_9 = lean_ctor_get(x_4, 3);
 lean_dec(x_9);
-x_10 = 0;
-lean_ctor_set(x_4, 0, x_6);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_10);
-x_11 = 1;
-x_12 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_12, 0, x_1);
-lean_ctor_set(x_12, 1, x_2);
-lean_ctor_set(x_12, 2, x_3);
-lean_ctor_set(x_12, 3, x_4);
-lean_ctor_set_uint8(x_12, sizeof(void*)*4, x_11);
-return x_12;
+x_10 = lean_ctor_get(x_4, 0);
+lean_dec(x_10);
+x_11 = 0;
+lean_ctor_set(x_4, 0, x_7);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_11);
+x_12 = 1;
+x_13 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_13, 0, x_1);
+lean_ctor_set(x_13, 1, x_2);
+lean_ctor_set(x_13, 2, x_3);
+lean_ctor_set(x_13, 3, x_4);
+lean_ctor_set_uint8(x_13, sizeof(void*)*4, x_12);
+return x_13;
 }
 else
 {
-lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; 
-x_13 = lean_ctor_get(x_4, 1);
-x_14 = lean_ctor_get(x_4, 2);
+lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; 
+x_14 = lean_ctor_get(x_4, 1);
+x_15 = lean_ctor_get(x_4, 2);
+lean_inc(x_15);
 lean_inc(x_14);
-lean_inc(x_13);
 lean_dec(x_4);
-x_15 = 0;
-x_16 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_16, 0, x_6);
-lean_ctor_set(x_16, 1, x_13);
-lean_ctor_set(x_16, 2, x_14);
-lean_ctor_set(x_16, 3, x_6);
-lean_ctor_set_uint8(x_16, sizeof(void*)*4, x_15);
-x_17 = 1;
-x_18 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_18, 0, x_1);
-lean_ctor_set(x_18, 1, x_2);
-lean_ctor_set(x_18, 2, x_3);
-lean_ctor_set(x_18, 3, x_16);
-lean_ctor_set_uint8(x_18, sizeof(void*)*4, x_17);
-return x_18;
+x_16 = 0;
+x_17 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_17, 0, x_7);
+lean_ctor_set(x_17, 1, x_14);
+lean_ctor_set(x_17, 2, x_15);
+lean_ctor_set(x_17, 3, x_7);
+lean_ctor_set_uint8(x_17, sizeof(void*)*4, x_16);
+x_18 = 1;
+x_19 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_19, 0, x_1);
+lean_ctor_set(x_19, 1, x_2);
+lean_ctor_set(x_19, 2, x_3);
+lean_ctor_set(x_19, 3, x_17);
+lean_ctor_set_uint8(x_19, sizeof(void*)*4, x_18);
+return x_19;
 }
 }
 else
 {
-uint8_t x_19; 
-x_19 = lean_ctor_get_uint8(x_6, sizeof(void*)*4);
-if (x_19 == 0)
-{
 uint8_t x_20; 
-x_20 = !lean_is_exclusive(x_4);
+x_20 = lean_ctor_get_uint8(x_7, sizeof(void*)*4);
 if (x_20 == 0)
 {
-lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
-x_21 = lean_ctor_get(x_4, 1);
-x_22 = lean_ctor_get(x_4, 2);
-x_23 = lean_ctor_get(x_4, 3);
-lean_dec(x_23);
-x_24 = lean_ctor_get(x_4, 0);
-lean_dec(x_24);
-x_25 = !lean_is_exclusive(x_6);
-if (x_25 == 0)
+uint8_t x_21; 
+x_21 = !lean_is_exclusive(x_4);
+if (x_21 == 0)
 {
-lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 
-x_26 = lean_ctor_get(x_6, 0);
-x_27 = lean_ctor_get(x_6, 1);
-x_28 = lean_ctor_get(x_6, 2);
-x_29 = lean_ctor_get(x_6, 3);
-x_30 = 1;
-lean_ctor_set(x_6, 3, x_5);
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
+x_22 = lean_ctor_get(x_4, 1);
+x_23 = lean_ctor_get(x_4, 2);
+x_24 = lean_ctor_get(x_4, 3);
+lean_dec(x_24);
+x_25 = lean_ctor_get(x_4, 0);
+lean_dec(x_25);
+x_26 = !lean_is_exclusive(x_7);
+if (x_26 == 0)
+{
+lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; uint8_t x_32; lean_object* x_33; 
+x_27 = lean_ctor_get(x_7, 0);
+x_28 = lean_ctor_get(x_7, 1);
+x_29 = lean_ctor_get(x_7, 2);
+x_30 = lean_ctor_get(x_7, 3);
+x_31 = 1;
+lean_ctor_set(x_7, 3, x_6);
+lean_ctor_set(x_7, 2, x_3);
+lean_ctor_set(x_7, 1, x_2);
+lean_ctor_set(x_7, 0, x_1);
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_31);
+lean_ctor_set(x_4, 3, x_30);
+lean_ctor_set(x_4, 2, x_29);
+lean_ctor_set(x_4, 1, x_28);
+lean_ctor_set(x_4, 0, x_27);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_31);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_7);
+lean_ctor_set(x_33, 1, x_22);
+lean_ctor_set(x_33, 2, x_23);
+lean_ctor_set(x_33, 3, x_4);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
+}
+else
+{
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; 
+x_34 = lean_ctor_get(x_7, 0);
+x_35 = lean_ctor_get(x_7, 1);
+x_36 = lean_ctor_get(x_7, 2);
+x_37 = lean_ctor_get(x_7, 3);
+lean_inc(x_37);
+lean_inc(x_36);
+lean_inc(x_35);
+lean_inc(x_34);
+lean_dec(x_7);
+x_38 = 1;
+x_39 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_39, 0, x_1);
+lean_ctor_set(x_39, 1, x_2);
+lean_ctor_set(x_39, 2, x_3);
+lean_ctor_set(x_39, 3, x_6);
+lean_ctor_set_uint8(x_39, sizeof(void*)*4, x_38);
+lean_ctor_set(x_4, 3, x_37);
+lean_ctor_set(x_4, 2, x_36);
+lean_ctor_set(x_4, 1, x_35);
+lean_ctor_set(x_4, 0, x_34);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_38);
+x_40 = 0;
+x_41 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_41, 0, x_39);
+lean_ctor_set(x_41, 1, x_22);
+lean_ctor_set(x_41, 2, x_23);
+lean_ctor_set(x_41, 3, x_4);
+lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_40);
+return x_41;
+}
+}
+else
+{
+lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; 
+x_42 = lean_ctor_get(x_4, 1);
+x_43 = lean_ctor_get(x_4, 2);
+lean_inc(x_43);
+lean_inc(x_42);
+lean_dec(x_4);
+x_44 = lean_ctor_get(x_7, 0);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_7, 1);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_7, 2);
+lean_inc(x_46);
+x_47 = lean_ctor_get(x_7, 3);
+lean_inc(x_47);
+if (lean_is_exclusive(x_7)) {
+ lean_ctor_release(x_7, 0);
+ lean_ctor_release(x_7, 1);
+ lean_ctor_release(x_7, 2);
+ lean_ctor_release(x_7, 3);
+ x_48 = x_7;
+} else {
+ lean_dec_ref(x_7);
+ x_48 = lean_box(0);
+}
+x_49 = 1;
+if (lean_is_scalar(x_48)) {
+ x_50 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_50 = x_48;
+}
+lean_ctor_set(x_50, 0, x_1);
+lean_ctor_set(x_50, 1, x_2);
+lean_ctor_set(x_50, 2, x_3);
+lean_ctor_set(x_50, 3, x_6);
+lean_ctor_set_uint8(x_50, sizeof(void*)*4, x_49);
+x_51 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_51, 0, x_44);
+lean_ctor_set(x_51, 1, x_45);
+lean_ctor_set(x_51, 2, x_46);
+lean_ctor_set(x_51, 3, x_47);
+lean_ctor_set_uint8(x_51, sizeof(void*)*4, x_49);
+x_52 = 0;
+x_53 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_53, 0, x_50);
+lean_ctor_set(x_53, 1, x_42);
+lean_ctor_set(x_53, 2, x_43);
+lean_ctor_set(x_53, 3, x_51);
+lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_52);
+return x_53;
+}
+}
+else
+{
+uint8_t x_54; 
+x_54 = !lean_is_exclusive(x_4);
+if (x_54 == 0)
+{
+lean_object* x_55; lean_object* x_56; uint8_t x_57; uint8_t x_58; lean_object* x_59; 
+x_55 = lean_ctor_get(x_4, 3);
+lean_dec(x_55);
+x_56 = lean_ctor_get(x_4, 0);
+lean_dec(x_56);
+x_57 = 0;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_57);
+x_58 = 1;
+x_59 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_59, 0, x_1);
+lean_ctor_set(x_59, 1, x_2);
+lean_ctor_set(x_59, 2, x_3);
+lean_ctor_set(x_59, 3, x_4);
+lean_ctor_set_uint8(x_59, sizeof(void*)*4, x_58);
+return x_59;
+}
+else
+{
+lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; uint8_t x_64; lean_object* x_65; 
+x_60 = lean_ctor_get(x_4, 1);
+x_61 = lean_ctor_get(x_4, 2);
+lean_inc(x_61);
+lean_inc(x_60);
+lean_dec(x_4);
+x_62 = 0;
+x_63 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_63, 0, x_6);
+lean_ctor_set(x_63, 1, x_60);
+lean_ctor_set(x_63, 2, x_61);
+lean_ctor_set(x_63, 3, x_7);
+lean_ctor_set_uint8(x_63, sizeof(void*)*4, x_62);
+x_64 = 1;
+x_65 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_65, 0, x_1);
+lean_ctor_set(x_65, 1, x_2);
+lean_ctor_set(x_65, 2, x_3);
+lean_ctor_set(x_65, 3, x_63);
+lean_ctor_set_uint8(x_65, sizeof(void*)*4, x_64);
+return x_65;
+}
+}
+}
+}
+else
+{
+uint8_t x_66; 
+x_66 = lean_ctor_get_uint8(x_6, sizeof(void*)*4);
+if (x_66 == 0)
+{
+uint8_t x_67; 
+x_67 = !lean_is_exclusive(x_4);
+if (x_67 == 0)
+{
+lean_object* x_68; uint8_t x_69; 
+x_68 = lean_ctor_get(x_4, 0);
+lean_dec(x_68);
+x_69 = !lean_is_exclusive(x_6);
+if (x_69 == 0)
+{
+lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; uint8_t x_75; lean_object* x_76; 
+x_70 = lean_ctor_get(x_6, 0);
+x_71 = lean_ctor_get(x_6, 1);
+x_72 = lean_ctor_get(x_6, 2);
+x_73 = lean_ctor_get(x_6, 3);
+x_74 = 1;
+lean_ctor_set(x_6, 3, x_70);
 lean_ctor_set(x_6, 2, x_3);
 lean_ctor_set(x_6, 1, x_2);
 lean_ctor_set(x_6, 0, x_1);
-lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_30);
-lean_ctor_set(x_4, 3, x_29);
-lean_ctor_set(x_4, 2, x_28);
-lean_ctor_set(x_4, 1, x_27);
-lean_ctor_set(x_4, 0, x_26);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_30);
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_6);
-lean_ctor_set(x_31, 1, x_21);
-lean_ctor_set(x_31, 2, x_22);
-lean_ctor_set(x_31, 3, x_4);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_19);
-return x_31;
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_74);
+lean_ctor_set(x_4, 0, x_73);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_74);
+x_75 = 0;
+x_76 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_76, 0, x_6);
+lean_ctor_set(x_76, 1, x_71);
+lean_ctor_set(x_76, 2, x_72);
+lean_ctor_set(x_76, 3, x_4);
+lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_75);
+return x_76;
 }
 else
 {
-lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; 
-x_32 = lean_ctor_get(x_6, 0);
-x_33 = lean_ctor_get(x_6, 1);
-x_34 = lean_ctor_get(x_6, 2);
-x_35 = lean_ctor_get(x_6, 3);
-lean_inc(x_35);
-lean_inc(x_34);
-lean_inc(x_33);
-lean_inc(x_32);
+lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; 
+x_77 = lean_ctor_get(x_6, 0);
+x_78 = lean_ctor_get(x_6, 1);
+x_79 = lean_ctor_get(x_6, 2);
+x_80 = lean_ctor_get(x_6, 3);
+lean_inc(x_80);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_inc(x_77);
 lean_dec(x_6);
-x_36 = 1;
-x_37 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_37, 0, x_1);
-lean_ctor_set(x_37, 1, x_2);
-lean_ctor_set(x_37, 2, x_3);
-lean_ctor_set(x_37, 3, x_5);
-lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
-lean_ctor_set(x_4, 3, x_35);
-lean_ctor_set(x_4, 2, x_34);
-lean_ctor_set(x_4, 1, x_33);
-lean_ctor_set(x_4, 0, x_32);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_36);
-x_38 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_38, 0, x_37);
-lean_ctor_set(x_38, 1, x_21);
-lean_ctor_set(x_38, 2, x_22);
-lean_ctor_set(x_38, 3, x_4);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_19);
-return x_38;
+x_81 = 1;
+x_82 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_82, 0, x_1);
+lean_ctor_set(x_82, 1, x_2);
+lean_ctor_set(x_82, 2, x_3);
+lean_ctor_set(x_82, 3, x_77);
+lean_ctor_set_uint8(x_82, sizeof(void*)*4, x_81);
+lean_ctor_set(x_4, 0, x_80);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_81);
+x_83 = 0;
+x_84 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_84, 0, x_82);
+lean_ctor_set(x_84, 1, x_78);
+lean_ctor_set(x_84, 2, x_79);
+lean_ctor_set(x_84, 3, x_4);
+lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
+return x_84;
 }
 }
 else
 {
-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; uint8_t x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; 
-x_39 = lean_ctor_get(x_4, 1);
-x_40 = lean_ctor_get(x_4, 2);
-lean_inc(x_40);
-lean_inc(x_39);
+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; uint8_t x_93; lean_object* x_94; lean_object* x_95; uint8_t x_96; lean_object* x_97; 
+x_85 = lean_ctor_get(x_4, 1);
+x_86 = lean_ctor_get(x_4, 2);
+x_87 = lean_ctor_get(x_4, 3);
+lean_inc(x_87);
+lean_inc(x_86);
+lean_inc(x_85);
 lean_dec(x_4);
-x_41 = lean_ctor_get(x_6, 0);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_6, 1);
-lean_inc(x_42);
-x_43 = lean_ctor_get(x_6, 2);
-lean_inc(x_43);
-x_44 = lean_ctor_get(x_6, 3);
-lean_inc(x_44);
+x_88 = lean_ctor_get(x_6, 0);
+lean_inc(x_88);
+x_89 = lean_ctor_get(x_6, 1);
+lean_inc(x_89);
+x_90 = lean_ctor_get(x_6, 2);
+lean_inc(x_90);
+x_91 = lean_ctor_get(x_6, 3);
+lean_inc(x_91);
 if (lean_is_exclusive(x_6)) {
  lean_ctor_release(x_6, 0);
  lean_ctor_release(x_6, 1);
  lean_ctor_release(x_6, 2);
  lean_ctor_release(x_6, 3);
- x_45 = x_6;
+ x_92 = x_6;
 } else {
  lean_dec_ref(x_6);
- x_45 = lean_box(0);
+ x_92 = lean_box(0);
 }
-x_46 = 1;
-if (lean_is_scalar(x_45)) {
- x_47 = lean_alloc_ctor(1, 4, 1);
+x_93 = 1;
+if (lean_is_scalar(x_92)) {
+ x_94 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_47 = x_45;
+ x_94 = x_92;
 }
-lean_ctor_set(x_47, 0, x_1);
-lean_ctor_set(x_47, 1, x_2);
-lean_ctor_set(x_47, 2, x_3);
-lean_ctor_set(x_47, 3, x_5);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_46);
-x_48 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_48, 0, x_41);
-lean_ctor_set(x_48, 1, x_42);
-lean_ctor_set(x_48, 2, x_43);
-lean_ctor_set(x_48, 3, x_44);
-lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_46);
-x_49 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_49, 0, x_47);
-lean_ctor_set(x_49, 1, x_39);
-lean_ctor_set(x_49, 2, x_40);
-lean_ctor_set(x_49, 3, x_48);
-lean_ctor_set_uint8(x_49, sizeof(void*)*4, x_19);
-return x_49;
-}
-}
-else
-{
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_4);
-if (x_50 == 0)
-{
-lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; 
-x_51 = lean_ctor_get(x_4, 3);
-lean_dec(x_51);
-x_52 = lean_ctor_get(x_4, 0);
-lean_dec(x_52);
-x_53 = 0;
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_53);
-x_54 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_54, 0, x_1);
-lean_ctor_set(x_54, 1, x_2);
-lean_ctor_set(x_54, 2, x_3);
-lean_ctor_set(x_54, 3, x_4);
-lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_19);
-return x_54;
-}
-else
-{
-lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; 
-x_55 = lean_ctor_get(x_4, 1);
-x_56 = lean_ctor_get(x_4, 2);
-lean_inc(x_56);
-lean_inc(x_55);
-lean_dec(x_4);
-x_57 = 0;
-x_58 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_58, 0, x_5);
-lean_ctor_set(x_58, 1, x_55);
-lean_ctor_set(x_58, 2, x_56);
-lean_ctor_set(x_58, 3, x_6);
-lean_ctor_set_uint8(x_58, sizeof(void*)*4, x_57);
-x_59 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_59, 0, x_1);
-lean_ctor_set(x_59, 1, x_2);
-lean_ctor_set(x_59, 2, x_3);
-lean_ctor_set(x_59, 3, x_58);
-lean_ctor_set_uint8(x_59, sizeof(void*)*4, x_19);
-return x_59;
-}
-}
-}
-}
-else
-{
-uint8_t x_60; 
-x_60 = lean_ctor_get_uint8(x_5, sizeof(void*)*4);
-if (x_60 == 0)
-{
-uint8_t x_61; 
-x_61 = !lean_is_exclusive(x_4);
-if (x_61 == 0)
-{
-lean_object* x_62; uint8_t x_63; 
-x_62 = lean_ctor_get(x_4, 0);
-lean_dec(x_62);
-x_63 = !lean_is_exclusive(x_5);
-if (x_63 == 0)
-{
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; 
-x_64 = lean_ctor_get(x_5, 0);
-x_65 = lean_ctor_get(x_5, 1);
-x_66 = lean_ctor_get(x_5, 2);
-x_67 = lean_ctor_get(x_5, 3);
-x_68 = 1;
-lean_ctor_set(x_5, 3, x_64);
-lean_ctor_set(x_5, 2, x_3);
-lean_ctor_set(x_5, 1, x_2);
-lean_ctor_set(x_5, 0, x_1);
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_68);
-lean_ctor_set(x_4, 0, x_67);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_68);
-x_69 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_69, 0, x_5);
-lean_ctor_set(x_69, 1, x_65);
-lean_ctor_set(x_69, 2, x_66);
-lean_ctor_set(x_69, 3, x_4);
-lean_ctor_set_uint8(x_69, sizeof(void*)*4, x_60);
-return x_69;
-}
-else
-{
-lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; lean_object* x_75; lean_object* x_76; 
-x_70 = lean_ctor_get(x_5, 0);
-x_71 = lean_ctor_get(x_5, 1);
-x_72 = lean_ctor_get(x_5, 2);
-x_73 = lean_ctor_get(x_5, 3);
-lean_inc(x_73);
-lean_inc(x_72);
-lean_inc(x_71);
-lean_inc(x_70);
-lean_dec(x_5);
-x_74 = 1;
-x_75 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_75, 0, x_1);
-lean_ctor_set(x_75, 1, x_2);
-lean_ctor_set(x_75, 2, x_3);
-lean_ctor_set(x_75, 3, x_70);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_74);
-lean_ctor_set(x_4, 0, x_73);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_74);
-x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_75);
-lean_ctor_set(x_76, 1, x_71);
-lean_ctor_set(x_76, 2, x_72);
-lean_ctor_set(x_76, 3, x_4);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_60);
-return x_76;
-}
-}
-else
-{
-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; uint8_t x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; 
-x_77 = lean_ctor_get(x_4, 1);
-x_78 = lean_ctor_get(x_4, 2);
-x_79 = lean_ctor_get(x_4, 3);
-lean_inc(x_79);
-lean_inc(x_78);
-lean_inc(x_77);
-lean_dec(x_4);
-x_80 = lean_ctor_get(x_5, 0);
-lean_inc(x_80);
-x_81 = lean_ctor_get(x_5, 1);
-lean_inc(x_81);
-x_82 = lean_ctor_get(x_5, 2);
-lean_inc(x_82);
-x_83 = lean_ctor_get(x_5, 3);
-lean_inc(x_83);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_84 = x_5;
-} else {
- lean_dec_ref(x_5);
- x_84 = lean_box(0);
-}
-x_85 = 1;
-if (lean_is_scalar(x_84)) {
- x_86 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_86 = x_84;
-}
-lean_ctor_set(x_86, 0, x_1);
-lean_ctor_set(x_86, 1, x_2);
-lean_ctor_set(x_86, 2, x_3);
-lean_ctor_set(x_86, 3, x_80);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
-x_87 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_87, 0, x_83);
-lean_ctor_set(x_87, 1, x_77);
-lean_ctor_set(x_87, 2, x_78);
-lean_ctor_set(x_87, 3, x_79);
-lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_85);
-x_88 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_88, 0, x_86);
-lean_ctor_set(x_88, 1, x_81);
-lean_ctor_set(x_88, 2, x_82);
-lean_ctor_set(x_88, 3, x_87);
-lean_ctor_set_uint8(x_88, sizeof(void*)*4, x_60);
-return x_88;
-}
-}
-else
-{
-lean_object* x_89; 
-x_89 = lean_ctor_get(x_4, 3);
-lean_inc(x_89);
-if (lean_obj_tag(x_89) == 0)
-{
-uint8_t x_90; 
-x_90 = !lean_is_exclusive(x_4);
-if (x_90 == 0)
-{
-lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; 
-x_91 = lean_ctor_get(x_4, 3);
-lean_dec(x_91);
-x_92 = lean_ctor_get(x_4, 0);
-lean_dec(x_92);
-x_93 = 0;
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_93);
-x_94 = lean_alloc_ctor(1, 4, 1);
 lean_ctor_set(x_94, 0, x_1);
 lean_ctor_set(x_94, 1, x_2);
 lean_ctor_set(x_94, 2, x_3);
-lean_ctor_set(x_94, 3, x_4);
-lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_60);
-return x_94;
+lean_ctor_set(x_94, 3, x_88);
+lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_93);
+x_95 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_95, 0, x_91);
+lean_ctor_set(x_95, 1, x_85);
+lean_ctor_set(x_95, 2, x_86);
+lean_ctor_set(x_95, 3, x_87);
+lean_ctor_set_uint8(x_95, sizeof(void*)*4, x_93);
+x_96 = 0;
+x_97 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_97, 0, x_94);
+lean_ctor_set(x_97, 1, x_89);
+lean_ctor_set(x_97, 2, x_90);
+lean_ctor_set(x_97, 3, x_95);
+lean_ctor_set_uint8(x_97, sizeof(void*)*4, x_96);
+return x_97;
+}
 }
 else
 {
-lean_object* x_95; lean_object* x_96; uint8_t x_97; lean_object* x_98; lean_object* x_99; 
-x_95 = lean_ctor_get(x_4, 1);
-x_96 = lean_ctor_get(x_4, 2);
-lean_inc(x_96);
-lean_inc(x_95);
+lean_object* x_98; 
+x_98 = lean_ctor_get(x_4, 3);
+lean_inc(x_98);
+if (lean_obj_tag(x_98) == 0)
+{
+uint8_t x_99; 
+x_99 = !lean_is_exclusive(x_4);
+if (x_99 == 0)
+{
+lean_object* x_100; lean_object* x_101; uint8_t x_102; uint8_t x_103; lean_object* x_104; 
+x_100 = lean_ctor_get(x_4, 3);
+lean_dec(x_100);
+x_101 = lean_ctor_get(x_4, 0);
+lean_dec(x_101);
+x_102 = 0;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_102);
+x_103 = 1;
+x_104 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_104, 0, x_1);
+lean_ctor_set(x_104, 1, x_2);
+lean_ctor_set(x_104, 2, x_3);
+lean_ctor_set(x_104, 3, x_4);
+lean_ctor_set_uint8(x_104, sizeof(void*)*4, x_103);
+return x_104;
+}
+else
+{
+lean_object* x_105; lean_object* x_106; uint8_t x_107; lean_object* x_108; uint8_t x_109; lean_object* x_110; 
+x_105 = lean_ctor_get(x_4, 1);
+x_106 = lean_ctor_get(x_4, 2);
+lean_inc(x_106);
+lean_inc(x_105);
 lean_dec(x_4);
-x_97 = 0;
-x_98 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_98, 0, x_5);
-lean_ctor_set(x_98, 1, x_95);
-lean_ctor_set(x_98, 2, x_96);
-lean_ctor_set(x_98, 3, x_89);
-lean_ctor_set_uint8(x_98, sizeof(void*)*4, x_97);
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_1);
-lean_ctor_set(x_99, 1, x_2);
-lean_ctor_set(x_99, 2, x_3);
-lean_ctor_set(x_99, 3, x_98);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_60);
-return x_99;
+x_107 = 0;
+x_108 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_108, 0, x_6);
+lean_ctor_set(x_108, 1, x_105);
+lean_ctor_set(x_108, 2, x_106);
+lean_ctor_set(x_108, 3, x_98);
+lean_ctor_set_uint8(x_108, sizeof(void*)*4, x_107);
+x_109 = 1;
+x_110 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_110, 0, x_1);
+lean_ctor_set(x_110, 1, x_2);
+lean_ctor_set(x_110, 2, x_3);
+lean_ctor_set(x_110, 3, x_108);
+lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_109);
+return x_110;
 }
 }
 else
 {
-uint8_t x_100; 
-x_100 = lean_ctor_get_uint8(x_89, sizeof(void*)*4);
-if (x_100 == 0)
+uint8_t x_111; 
+x_111 = lean_ctor_get_uint8(x_98, sizeof(void*)*4);
+if (x_111 == 0)
 {
-uint8_t x_101; 
-x_101 = !lean_is_exclusive(x_4);
-if (x_101 == 0)
+uint8_t x_112; 
+x_112 = !lean_is_exclusive(x_4);
+if (x_112 == 0)
 {
-lean_object* x_102; lean_object* x_103; uint8_t x_104; 
-x_102 = lean_ctor_get(x_4, 3);
-lean_dec(x_102);
-x_103 = lean_ctor_get(x_4, 0);
-lean_dec(x_103);
-x_104 = !lean_is_exclusive(x_89);
-if (x_104 == 0)
-{
-lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; uint8_t x_109; 
-x_105 = lean_ctor_get(x_89, 0);
-x_106 = lean_ctor_get(x_89, 1);
-x_107 = lean_ctor_get(x_89, 2);
-x_108 = lean_ctor_get(x_89, 3);
-lean_inc(x_5);
-lean_ctor_set(x_89, 3, x_5);
-lean_ctor_set(x_89, 2, x_3);
-lean_ctor_set(x_89, 1, x_2);
-lean_ctor_set(x_89, 0, x_1);
-x_109 = !lean_is_exclusive(x_5);
-if (x_109 == 0)
-{
-lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; 
-x_110 = lean_ctor_get(x_5, 3);
-lean_dec(x_110);
-x_111 = lean_ctor_get(x_5, 2);
-lean_dec(x_111);
-x_112 = lean_ctor_get(x_5, 1);
-lean_dec(x_112);
-x_113 = lean_ctor_get(x_5, 0);
+lean_object* x_113; lean_object* x_114; uint8_t x_115; 
+x_113 = lean_ctor_get(x_4, 3);
 lean_dec(x_113);
-lean_ctor_set_uint8(x_89, sizeof(void*)*4, x_60);
-lean_ctor_set(x_5, 3, x_108);
-lean_ctor_set(x_5, 2, x_107);
-lean_ctor_set(x_5, 1, x_106);
-lean_ctor_set(x_5, 0, x_105);
-lean_ctor_set(x_4, 3, x_5);
-lean_ctor_set(x_4, 0, x_89);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_100);
+x_114 = lean_ctor_get(x_4, 0);
+lean_dec(x_114);
+x_115 = !lean_is_exclusive(x_98);
+if (x_115 == 0)
+{
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; uint8_t x_120; uint8_t x_121; 
+x_116 = lean_ctor_get(x_98, 0);
+x_117 = lean_ctor_get(x_98, 1);
+x_118 = lean_ctor_get(x_98, 2);
+x_119 = lean_ctor_get(x_98, 3);
+x_120 = 1;
+lean_inc(x_6);
+lean_ctor_set(x_98, 3, x_6);
+lean_ctor_set(x_98, 2, x_3);
+lean_ctor_set(x_98, 1, x_2);
+lean_ctor_set(x_98, 0, x_1);
+x_121 = !lean_is_exclusive(x_6);
+if (x_121 == 0)
+{
+lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; 
+x_122 = lean_ctor_get(x_6, 3);
+lean_dec(x_122);
+x_123 = lean_ctor_get(x_6, 2);
+lean_dec(x_123);
+x_124 = lean_ctor_get(x_6, 1);
+lean_dec(x_124);
+x_125 = lean_ctor_get(x_6, 0);
+lean_dec(x_125);
+lean_ctor_set_uint8(x_98, sizeof(void*)*4, x_120);
+lean_ctor_set(x_6, 3, x_119);
+lean_ctor_set(x_6, 2, x_118);
+lean_ctor_set(x_6, 1, x_117);
+lean_ctor_set(x_6, 0, x_116);
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_120);
+x_126 = 0;
+lean_ctor_set(x_4, 3, x_6);
+lean_ctor_set(x_4, 0, x_98);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_126);
 return x_4;
 }
 else
 {
-lean_object* x_114; 
-lean_dec(x_5);
-lean_ctor_set_uint8(x_89, sizeof(void*)*4, x_60);
-x_114 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_114, 0, x_105);
-lean_ctor_set(x_114, 1, x_106);
-lean_ctor_set(x_114, 2, x_107);
-lean_ctor_set(x_114, 3, x_108);
-lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_60);
-lean_ctor_set(x_4, 3, x_114);
-lean_ctor_set(x_4, 0, x_89);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_100);
+lean_object* x_127; uint8_t x_128; 
+lean_dec(x_6);
+lean_ctor_set_uint8(x_98, sizeof(void*)*4, x_120);
+x_127 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_127, 0, x_116);
+lean_ctor_set(x_127, 1, x_117);
+lean_ctor_set(x_127, 2, x_118);
+lean_ctor_set(x_127, 3, x_119);
+lean_ctor_set_uint8(x_127, sizeof(void*)*4, x_120);
+x_128 = 0;
+lean_ctor_set(x_4, 3, x_127);
+lean_ctor_set(x_4, 0, x_98);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_128);
 return x_4;
 }
 }
 else
 {
-lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; 
-x_115 = lean_ctor_get(x_89, 0);
-x_116 = lean_ctor_get(x_89, 1);
-x_117 = lean_ctor_get(x_89, 2);
-x_118 = lean_ctor_get(x_89, 3);
-lean_inc(x_118);
-lean_inc(x_117);
-lean_inc(x_116);
-lean_inc(x_115);
-lean_dec(x_89);
-lean_inc(x_5);
-x_119 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_119, 0, x_1);
-lean_ctor_set(x_119, 1, x_2);
-lean_ctor_set(x_119, 2, x_3);
-lean_ctor_set(x_119, 3, x_5);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_120 = x_5;
+lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; uint8_t x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; uint8_t x_137; 
+x_129 = lean_ctor_get(x_98, 0);
+x_130 = lean_ctor_get(x_98, 1);
+x_131 = lean_ctor_get(x_98, 2);
+x_132 = lean_ctor_get(x_98, 3);
+lean_inc(x_132);
+lean_inc(x_131);
+lean_inc(x_130);
+lean_inc(x_129);
+lean_dec(x_98);
+x_133 = 1;
+lean_inc(x_6);
+x_134 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_134, 0, x_1);
+lean_ctor_set(x_134, 1, x_2);
+lean_ctor_set(x_134, 2, x_3);
+lean_ctor_set(x_134, 3, x_6);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ lean_ctor_release(x_6, 2);
+ lean_ctor_release(x_6, 3);
+ x_135 = x_6;
 } else {
- lean_dec_ref(x_5);
- x_120 = lean_box(0);
+ lean_dec_ref(x_6);
+ x_135 = lean_box(0);
 }
-lean_ctor_set_uint8(x_119, sizeof(void*)*4, x_60);
-if (lean_is_scalar(x_120)) {
- x_121 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set_uint8(x_134, sizeof(void*)*4, x_133);
+if (lean_is_scalar(x_135)) {
+ x_136 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_121 = x_120;
+ x_136 = x_135;
 }
-lean_ctor_set(x_121, 0, x_115);
-lean_ctor_set(x_121, 1, x_116);
-lean_ctor_set(x_121, 2, x_117);
-lean_ctor_set(x_121, 3, x_118);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_60);
-lean_ctor_set(x_4, 3, x_121);
-lean_ctor_set(x_4, 0, x_119);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_100);
-return x_4;
-}
-}
-else
-{
-lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; 
-x_122 = lean_ctor_get(x_4, 1);
-x_123 = lean_ctor_get(x_4, 2);
-lean_inc(x_123);
-lean_inc(x_122);
-lean_dec(x_4);
-x_124 = lean_ctor_get(x_89, 0);
-lean_inc(x_124);
-x_125 = lean_ctor_get(x_89, 1);
-lean_inc(x_125);
-x_126 = lean_ctor_get(x_89, 2);
-lean_inc(x_126);
-x_127 = lean_ctor_get(x_89, 3);
-lean_inc(x_127);
-if (lean_is_exclusive(x_89)) {
- lean_ctor_release(x_89, 0);
- lean_ctor_release(x_89, 1);
- lean_ctor_release(x_89, 2);
- lean_ctor_release(x_89, 3);
- x_128 = x_89;
-} else {
- lean_dec_ref(x_89);
- x_128 = lean_box(0);
-}
-lean_inc(x_5);
-if (lean_is_scalar(x_128)) {
- x_129 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_129 = x_128;
-}
-lean_ctor_set(x_129, 0, x_1);
-lean_ctor_set(x_129, 1, x_2);
-lean_ctor_set(x_129, 2, x_3);
-lean_ctor_set(x_129, 3, x_5);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_130 = x_5;
-} else {
- lean_dec_ref(x_5);
- x_130 = lean_box(0);
-}
-lean_ctor_set_uint8(x_129, sizeof(void*)*4, x_60);
-if (lean_is_scalar(x_130)) {
- x_131 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_131 = x_130;
-}
-lean_ctor_set(x_131, 0, x_124);
-lean_ctor_set(x_131, 1, x_125);
-lean_ctor_set(x_131, 2, x_126);
-lean_ctor_set(x_131, 3, x_127);
-lean_ctor_set_uint8(x_131, sizeof(void*)*4, x_60);
-x_132 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_132, 0, x_129);
-lean_ctor_set(x_132, 1, x_122);
-lean_ctor_set(x_132, 2, x_123);
-lean_ctor_set(x_132, 3, x_131);
-lean_ctor_set_uint8(x_132, sizeof(void*)*4, x_100);
-return x_132;
-}
-}
-else
-{
-uint8_t x_133; 
-x_133 = !lean_is_exclusive(x_4);
-if (x_133 == 0)
-{
-lean_object* x_134; lean_object* x_135; uint8_t x_136; 
-x_134 = lean_ctor_get(x_4, 3);
-lean_dec(x_134);
-x_135 = lean_ctor_get(x_4, 0);
-lean_dec(x_135);
-x_136 = !lean_is_exclusive(x_5);
-if (x_136 == 0)
-{
-uint8_t x_137; lean_object* x_138; 
-lean_ctor_set_uint8(x_5, sizeof(void*)*4, x_100);
+lean_ctor_set(x_136, 0, x_129);
+lean_ctor_set(x_136, 1, x_130);
+lean_ctor_set(x_136, 2, x_131);
+lean_ctor_set(x_136, 3, x_132);
+lean_ctor_set_uint8(x_136, sizeof(void*)*4, x_133);
 x_137 = 0;
+lean_ctor_set(x_4, 3, x_136);
+lean_ctor_set(x_4, 0, x_134);
 lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_137);
-x_138 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_138, 0, x_1);
-lean_ctor_set(x_138, 1, x_2);
-lean_ctor_set(x_138, 2, x_3);
-lean_ctor_set(x_138, 3, x_4);
-lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_100);
-return x_138;
+return x_4;
+}
 }
 else
 {
-lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; uint8_t x_144; lean_object* x_145; 
-x_139 = lean_ctor_get(x_5, 0);
-x_140 = lean_ctor_get(x_5, 1);
-x_141 = lean_ctor_get(x_5, 2);
-x_142 = lean_ctor_get(x_5, 3);
-lean_inc(x_142);
-lean_inc(x_141);
-lean_inc(x_140);
+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_146; lean_object* x_147; lean_object* x_148; uint8_t x_149; lean_object* x_150; 
+x_138 = lean_ctor_get(x_4, 1);
+x_139 = lean_ctor_get(x_4, 2);
 lean_inc(x_139);
-lean_dec(x_5);
-x_143 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_143, 0, x_139);
-lean_ctor_set(x_143, 1, x_140);
-lean_ctor_set(x_143, 2, x_141);
-lean_ctor_set(x_143, 3, x_142);
-lean_ctor_set_uint8(x_143, sizeof(void*)*4, x_100);
-x_144 = 0;
-lean_ctor_set(x_4, 0, x_143);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_144);
-x_145 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_145, 0, x_1);
-lean_ctor_set(x_145, 1, x_2);
-lean_ctor_set(x_145, 2, x_3);
-lean_ctor_set(x_145, 3, x_4);
-lean_ctor_set_uint8(x_145, sizeof(void*)*4, x_100);
-return x_145;
+lean_inc(x_138);
+lean_dec(x_4);
+x_140 = lean_ctor_get(x_98, 0);
+lean_inc(x_140);
+x_141 = lean_ctor_get(x_98, 1);
+lean_inc(x_141);
+x_142 = lean_ctor_get(x_98, 2);
+lean_inc(x_142);
+x_143 = lean_ctor_get(x_98, 3);
+lean_inc(x_143);
+if (lean_is_exclusive(x_98)) {
+ lean_ctor_release(x_98, 0);
+ lean_ctor_release(x_98, 1);
+ lean_ctor_release(x_98, 2);
+ lean_ctor_release(x_98, 3);
+ x_144 = x_98;
+} else {
+ lean_dec_ref(x_98);
+ x_144 = lean_box(0);
+}
+x_145 = 1;
+lean_inc(x_6);
+if (lean_is_scalar(x_144)) {
+ x_146 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_146 = x_144;
+}
+lean_ctor_set(x_146, 0, x_1);
+lean_ctor_set(x_146, 1, x_2);
+lean_ctor_set(x_146, 2, x_3);
+lean_ctor_set(x_146, 3, x_6);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ lean_ctor_release(x_6, 2);
+ lean_ctor_release(x_6, 3);
+ x_147 = x_6;
+} else {
+ lean_dec_ref(x_6);
+ x_147 = lean_box(0);
+}
+lean_ctor_set_uint8(x_146, sizeof(void*)*4, x_145);
+if (lean_is_scalar(x_147)) {
+ x_148 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_148 = x_147;
+}
+lean_ctor_set(x_148, 0, x_140);
+lean_ctor_set(x_148, 1, x_141);
+lean_ctor_set(x_148, 2, x_142);
+lean_ctor_set(x_148, 3, x_143);
+lean_ctor_set_uint8(x_148, sizeof(void*)*4, x_145);
+x_149 = 0;
+x_150 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_150, 0, x_146);
+lean_ctor_set(x_150, 1, x_138);
+lean_ctor_set(x_150, 2, x_139);
+lean_ctor_set(x_150, 3, x_148);
+lean_ctor_set_uint8(x_150, sizeof(void*)*4, x_149);
+return x_150;
 }
 }
 else
 {
-lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint8_t x_154; lean_object* x_155; lean_object* x_156; 
-x_146 = lean_ctor_get(x_4, 1);
-x_147 = lean_ctor_get(x_4, 2);
-lean_inc(x_147);
-lean_inc(x_146);
+uint8_t x_151; 
+x_151 = !lean_is_exclusive(x_4);
+if (x_151 == 0)
+{
+lean_object* x_152; lean_object* x_153; uint8_t x_154; 
+x_152 = lean_ctor_get(x_4, 3);
+lean_dec(x_152);
+x_153 = lean_ctor_get(x_4, 0);
+lean_dec(x_153);
+x_154 = !lean_is_exclusive(x_6);
+if (x_154 == 0)
+{
+uint8_t x_155; uint8_t x_156; lean_object* x_157; 
+lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_111);
+x_155 = 0;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_155);
+x_156 = 1;
+x_157 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_157, 0, x_1);
+lean_ctor_set(x_157, 1, x_2);
+lean_ctor_set(x_157, 2, x_3);
+lean_ctor_set(x_157, 3, x_4);
+lean_ctor_set_uint8(x_157, sizeof(void*)*4, x_156);
+return x_157;
+}
+else
+{
+lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; uint8_t x_163; uint8_t x_164; lean_object* x_165; 
+x_158 = lean_ctor_get(x_6, 0);
+x_159 = lean_ctor_get(x_6, 1);
+x_160 = lean_ctor_get(x_6, 2);
+x_161 = lean_ctor_get(x_6, 3);
+lean_inc(x_161);
+lean_inc(x_160);
+lean_inc(x_159);
+lean_inc(x_158);
+lean_dec(x_6);
+x_162 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_162, 0, x_158);
+lean_ctor_set(x_162, 1, x_159);
+lean_ctor_set(x_162, 2, x_160);
+lean_ctor_set(x_162, 3, x_161);
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_111);
+x_163 = 0;
+lean_ctor_set(x_4, 0, x_162);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_163);
+x_164 = 1;
+x_165 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_165, 0, x_1);
+lean_ctor_set(x_165, 1, x_2);
+lean_ctor_set(x_165, 2, x_3);
+lean_ctor_set(x_165, 3, x_4);
+lean_ctor_set_uint8(x_165, sizeof(void*)*4, x_164);
+return x_165;
+}
+}
+else
+{
+lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; lean_object* x_175; uint8_t x_176; lean_object* x_177; 
+x_166 = lean_ctor_get(x_4, 1);
+x_167 = lean_ctor_get(x_4, 2);
+lean_inc(x_167);
+lean_inc(x_166);
 lean_dec(x_4);
-x_148 = lean_ctor_get(x_5, 0);
-lean_inc(x_148);
-x_149 = lean_ctor_get(x_5, 1);
-lean_inc(x_149);
-x_150 = lean_ctor_get(x_5, 2);
-lean_inc(x_150);
-x_151 = lean_ctor_get(x_5, 3);
-lean_inc(x_151);
-if (lean_is_exclusive(x_5)) {
- lean_ctor_release(x_5, 0);
- lean_ctor_release(x_5, 1);
- lean_ctor_release(x_5, 2);
- lean_ctor_release(x_5, 3);
- x_152 = x_5;
+x_168 = lean_ctor_get(x_6, 0);
+lean_inc(x_168);
+x_169 = lean_ctor_get(x_6, 1);
+lean_inc(x_169);
+x_170 = lean_ctor_get(x_6, 2);
+lean_inc(x_170);
+x_171 = lean_ctor_get(x_6, 3);
+lean_inc(x_171);
+if (lean_is_exclusive(x_6)) {
+ lean_ctor_release(x_6, 0);
+ lean_ctor_release(x_6, 1);
+ lean_ctor_release(x_6, 2);
+ lean_ctor_release(x_6, 3);
+ x_172 = x_6;
 } else {
- lean_dec_ref(x_5);
- x_152 = lean_box(0);
+ lean_dec_ref(x_6);
+ x_172 = lean_box(0);
 }
-if (lean_is_scalar(x_152)) {
- x_153 = lean_alloc_ctor(1, 4, 1);
+if (lean_is_scalar(x_172)) {
+ x_173 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_153 = x_152;
+ x_173 = x_172;
 }
-lean_ctor_set(x_153, 0, x_148);
-lean_ctor_set(x_153, 1, x_149);
-lean_ctor_set(x_153, 2, x_150);
-lean_ctor_set(x_153, 3, x_151);
-lean_ctor_set_uint8(x_153, sizeof(void*)*4, x_100);
-x_154 = 0;
-x_155 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_155, 0, x_153);
-lean_ctor_set(x_155, 1, x_146);
-lean_ctor_set(x_155, 2, x_147);
-lean_ctor_set(x_155, 3, x_89);
-lean_ctor_set_uint8(x_155, sizeof(void*)*4, x_154);
-x_156 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_156, 0, x_1);
-lean_ctor_set(x_156, 1, x_2);
-lean_ctor_set(x_156, 2, x_3);
-lean_ctor_set(x_156, 3, x_155);
-lean_ctor_set_uint8(x_156, sizeof(void*)*4, x_100);
-return x_156;
+lean_ctor_set(x_173, 0, x_168);
+lean_ctor_set(x_173, 1, x_169);
+lean_ctor_set(x_173, 2, x_170);
+lean_ctor_set(x_173, 3, x_171);
+lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_111);
+x_174 = 0;
+x_175 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_175, 0, x_173);
+lean_ctor_set(x_175, 1, x_166);
+lean_ctor_set(x_175, 2, x_167);
+lean_ctor_set(x_175, 3, x_98);
+lean_ctor_set_uint8(x_175, sizeof(void*)*4, x_174);
+x_176 = 1;
+x_177 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_177, 0, x_1);
+lean_ctor_set(x_177, 1, x_2);
+lean_ctor_set(x_177, 2, x_3);
+lean_ctor_set(x_177, 3, x_175);
+lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_176);
+return x_177;
 }
 }
 }
@@ -2319,6 +3051,54 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_balance2___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_isRed_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 2);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 3);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_apply_4(x_2, x_6, x_7, x_8, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_2);
+x_11 = lean_apply_1(x_3, x_1);
+return x_11;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_isRed_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_isRed_match__1___rarg), 3, 0);
+return x_4;
+}
+}
 uint8_t l_Std_RBNode_isRed___rarg(lean_object* x_1) {
 _start:
 {
@@ -2365,6 +3145,54 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_isBlack_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_5 == 0)
+{
+lean_object* x_6; 
+lean_dec(x_2);
+x_6 = lean_apply_1(x_3, x_1);
+return x_6;
+}
+else
+{
+lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
+lean_dec(x_3);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_apply_4(x_2, x_7, x_8, x_9, x_10);
+return x_11;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_isBlack_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_isBlack_match__1___rarg), 3, 0);
+return x_4;
+}
+}
 uint8_t l_Std_RBNode_isBlack___rarg(lean_object* x_1) {
 _start:
 {
@@ -2411,2450 +3239,2570 @@ x_3 = lean_box(x_2);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_ins___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_ins_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
-if (lean_obj_tag(x_2) == 0)
+if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_5; lean_object* x_6; 
-lean_dec(x_1);
-x_5 = 0;
-x_6 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_6, 0, x_2);
-lean_ctor_set(x_6, 1, x_3);
-lean_ctor_set(x_6, 2, x_4);
-lean_ctor_set(x_6, 3, x_2);
-lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5);
-return x_6;
+lean_object* x_7; 
+lean_dec(x_6);
+lean_dec(x_5);
+x_7 = lean_apply_2(x_4, x_2, x_3);
+return x_7;
 }
 else
 {
-uint8_t x_7; 
-x_7 = lean_ctor_get_uint8(x_2, sizeof(void*)*4);
-if (x_7 == 0)
-{
 uint8_t x_8; 
-x_8 = !lean_is_exclusive(x_2);
+lean_dec(x_4);
+x_8 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
 if (x_8 == 0)
 {
-lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; uint8_t x_14; 
-x_9 = lean_ctor_get(x_2, 0);
-x_10 = lean_ctor_get(x_2, 1);
-x_11 = lean_ctor_get(x_2, 2);
-x_12 = lean_ctor_get(x_2, 3);
-lean_inc(x_1);
+lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_6);
+x_9 = lean_ctor_get(x_1, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 1);
 lean_inc(x_10);
-lean_inc(x_3);
-x_13 = lean_apply_2(x_1, x_3, x_10);
-x_14 = lean_unbox(x_13);
-lean_dec(x_13);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-lean_inc(x_1);
-lean_inc(x_3);
-lean_inc(x_10);
-x_15 = lean_apply_2(x_1, x_10, x_3);
-x_16 = lean_unbox(x_15);
-lean_dec(x_15);
-if (x_16 == 0)
-{
-lean_dec(x_11);
-lean_dec(x_10);
+x_11 = lean_ctor_get(x_1, 2);
+lean_inc(x_11);
+x_12 = lean_ctor_get(x_1, 3);
+lean_inc(x_12);
 lean_dec(x_1);
-lean_ctor_set(x_2, 2, x_4);
-lean_ctor_set(x_2, 1, x_3);
-return x_2;
+x_13 = lean_apply_6(x_5, x_9, x_10, x_11, x_12, x_2, x_3);
+return x_13;
 }
 else
 {
-lean_object* x_17; 
-x_17 = l_Std_RBNode_ins___main___rarg(x_1, x_12, x_3, x_4);
-lean_ctor_set(x_2, 3, x_17);
-return x_2;
-}
-}
-else
-{
-lean_object* x_18; 
-x_18 = l_Std_RBNode_ins___main___rarg(x_1, x_9, x_3, x_4);
-lean_ctor_set(x_2, 0, x_18);
-return x_2;
-}
-}
-else
-{
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
-x_19 = lean_ctor_get(x_2, 0);
-x_20 = lean_ctor_get(x_2, 1);
-x_21 = lean_ctor_get(x_2, 2);
-x_22 = lean_ctor_get(x_2, 3);
-lean_inc(x_22);
-lean_inc(x_21);
-lean_inc(x_20);
-lean_inc(x_19);
-lean_dec(x_2);
-lean_inc(x_1);
-lean_inc(x_20);
-lean_inc(x_3);
-x_23 = lean_apply_2(x_1, x_3, x_20);
-x_24 = lean_unbox(x_23);
-lean_dec(x_23);
-if (x_24 == 0)
-{
-lean_object* x_25; uint8_t x_26; 
-lean_inc(x_1);
-lean_inc(x_3);
-lean_inc(x_20);
-x_25 = lean_apply_2(x_1, x_20, x_3);
-x_26 = lean_unbox(x_25);
-lean_dec(x_25);
-if (x_26 == 0)
-{
-lean_object* x_27; 
-lean_dec(x_21);
-lean_dec(x_20);
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
+lean_dec(x_5);
+x_14 = lean_ctor_get(x_1, 0);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_1, 1);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 2);
+lean_inc(x_16);
+x_17 = lean_ctor_get(x_1, 3);
+lean_inc(x_17);
 lean_dec(x_1);
-x_27 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_27, 0, x_19);
-lean_ctor_set(x_27, 1, x_3);
-lean_ctor_set(x_27, 2, x_4);
-lean_ctor_set(x_27, 3, x_22);
-lean_ctor_set_uint8(x_27, sizeof(void*)*4, x_7);
-return x_27;
+x_18 = lean_apply_6(x_6, x_14, x_15, x_16, x_17, x_2, x_3);
+return x_18;
 }
-else
-{
-lean_object* x_28; lean_object* x_29; 
-x_28 = l_Std_RBNode_ins___main___rarg(x_1, x_22, x_3, x_4);
-x_29 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_29, 0, x_19);
-lean_ctor_set(x_29, 1, x_20);
-lean_ctor_set(x_29, 2, x_21);
-lean_ctor_set(x_29, 3, x_28);
-lean_ctor_set_uint8(x_29, sizeof(void*)*4, x_7);
-return x_29;
 }
 }
-else
-{
-lean_object* x_30; lean_object* x_31; 
-x_30 = l_Std_RBNode_ins___main___rarg(x_1, x_19, x_3, x_4);
-x_31 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_31, 0, x_30);
-lean_ctor_set(x_31, 1, x_20);
-lean_ctor_set(x_31, 2, x_21);
-lean_ctor_set(x_31, 3, x_22);
-lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_7);
-return x_31;
 }
-}
-}
-else
-{
-uint8_t x_32; 
-x_32 = !lean_is_exclusive(x_2);
-if (x_32 == 0)
-{
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; uint8_t x_38; 
-x_33 = lean_ctor_get(x_2, 0);
-x_34 = lean_ctor_get(x_2, 1);
-x_35 = lean_ctor_get(x_2, 2);
-x_36 = lean_ctor_get(x_2, 3);
-lean_inc(x_1);
-lean_inc(x_34);
-lean_inc(x_3);
-x_37 = lean_apply_2(x_1, x_3, x_34);
-x_38 = lean_unbox(x_37);
-lean_dec(x_37);
-if (x_38 == 0)
-{
-lean_object* x_39; uint8_t x_40; 
-lean_inc(x_1);
-lean_inc(x_3);
-lean_inc(x_34);
-x_39 = lean_apply_2(x_1, x_34, x_3);
-x_40 = lean_unbox(x_39);
-lean_dec(x_39);
-if (x_40 == 0)
-{
-lean_dec(x_35);
-lean_dec(x_34);
-lean_dec(x_1);
-lean_ctor_set(x_2, 2, x_4);
-lean_ctor_set(x_2, 1, x_3);
-return x_2;
-}
-else
-{
-uint8_t x_41; 
-x_41 = l_Std_RBNode_isRed___rarg(x_36);
-if (x_41 == 0)
-{
-lean_object* x_42; 
-x_42 = l_Std_RBNode_ins___main___rarg(x_1, x_36, x_3, x_4);
-lean_ctor_set(x_2, 3, x_42);
-return x_2;
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-x_43 = l_Std_RBNode_ins___main___rarg(x_1, x_36, x_3, x_4);
-x_44 = lean_ctor_get(x_43, 0);
-lean_inc(x_44);
-if (lean_obj_tag(x_44) == 0)
-{
-lean_object* x_45; 
-x_45 = lean_ctor_get(x_43, 3);
-lean_inc(x_45);
-if (lean_obj_tag(x_45) == 0)
-{
-uint8_t x_46; 
-x_46 = !lean_is_exclusive(x_43);
-if (x_46 == 0)
-{
-lean_object* x_47; lean_object* x_48; uint8_t x_49; uint8_t x_50; 
-x_47 = lean_ctor_get(x_43, 3);
-lean_dec(x_47);
-x_48 = lean_ctor_get(x_43, 0);
-lean_dec(x_48);
-x_49 = 0;
-lean_ctor_set(x_43, 0, x_45);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_49);
-x_50 = 1;
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_50);
-return x_2;
-}
-else
-{
-lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; 
-x_51 = lean_ctor_get(x_43, 1);
-x_52 = lean_ctor_get(x_43, 2);
-lean_inc(x_52);
-lean_inc(x_51);
-lean_dec(x_43);
-x_53 = 0;
-x_54 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_54, 0, x_45);
-lean_ctor_set(x_54, 1, x_51);
-lean_ctor_set(x_54, 2, x_52);
-lean_ctor_set(x_54, 3, x_45);
-lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_53);
-x_55 = 1;
-lean_ctor_set(x_2, 3, x_54);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_55);
-return x_2;
-}
-}
-else
-{
-uint8_t x_56; 
-x_56 = lean_ctor_get_uint8(x_45, sizeof(void*)*4);
-if (x_56 == 0)
-{
-uint8_t x_57; 
-x_57 = !lean_is_exclusive(x_43);
-if (x_57 == 0)
-{
-lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_58 = lean_ctor_get(x_43, 1);
-x_59 = lean_ctor_get(x_43, 2);
-x_60 = lean_ctor_get(x_43, 3);
-lean_dec(x_60);
-x_61 = lean_ctor_get(x_43, 0);
-lean_dec(x_61);
-x_62 = !lean_is_exclusive(x_45);
-if (x_62 == 0)
-{
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; 
-x_63 = lean_ctor_get(x_45, 0);
-x_64 = lean_ctor_get(x_45, 1);
-x_65 = lean_ctor_get(x_45, 2);
-x_66 = lean_ctor_get(x_45, 3);
-x_67 = 1;
-lean_ctor_set(x_45, 3, x_44);
-lean_ctor_set(x_45, 2, x_35);
-lean_ctor_set(x_45, 1, x_34);
-lean_ctor_set(x_45, 0, x_33);
-lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_67);
-lean_ctor_set(x_43, 3, x_66);
-lean_ctor_set(x_43, 2, x_65);
-lean_ctor_set(x_43, 1, x_64);
-lean_ctor_set(x_43, 0, x_63);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_67);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set(x_2, 2, x_59);
-lean_ctor_set(x_2, 1, x_58);
-lean_ctor_set(x_2, 0, x_45);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_56);
-return x_2;
-}
-else
-{
-lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; uint8_t x_72; lean_object* x_73; 
-x_68 = lean_ctor_get(x_45, 0);
-x_69 = lean_ctor_get(x_45, 1);
-x_70 = lean_ctor_get(x_45, 2);
-x_71 = lean_ctor_get(x_45, 3);
-lean_inc(x_71);
-lean_inc(x_70);
-lean_inc(x_69);
-lean_inc(x_68);
-lean_dec(x_45);
-x_72 = 1;
-x_73 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_73, 0, x_33);
-lean_ctor_set(x_73, 1, x_34);
-lean_ctor_set(x_73, 2, x_35);
-lean_ctor_set(x_73, 3, x_44);
-lean_ctor_set_uint8(x_73, sizeof(void*)*4, x_72);
-lean_ctor_set(x_43, 3, x_71);
-lean_ctor_set(x_43, 2, x_70);
-lean_ctor_set(x_43, 1, x_69);
-lean_ctor_set(x_43, 0, x_68);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_72);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set(x_2, 2, x_59);
-lean_ctor_set(x_2, 1, x_58);
-lean_ctor_set(x_2, 0, x_73);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_56);
-return x_2;
-}
-}
-else
-{
-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; lean_object* x_82; lean_object* x_83; 
-x_74 = lean_ctor_get(x_43, 1);
-x_75 = lean_ctor_get(x_43, 2);
-lean_inc(x_75);
-lean_inc(x_74);
-lean_dec(x_43);
-x_76 = lean_ctor_get(x_45, 0);
-lean_inc(x_76);
-x_77 = lean_ctor_get(x_45, 1);
-lean_inc(x_77);
-x_78 = lean_ctor_get(x_45, 2);
-lean_inc(x_78);
-x_79 = lean_ctor_get(x_45, 3);
-lean_inc(x_79);
-if (lean_is_exclusive(x_45)) {
- lean_ctor_release(x_45, 0);
- lean_ctor_release(x_45, 1);
- lean_ctor_release(x_45, 2);
- lean_ctor_release(x_45, 3);
- x_80 = x_45;
-} else {
- lean_dec_ref(x_45);
- x_80 = lean_box(0);
-}
-x_81 = 1;
-if (lean_is_scalar(x_80)) {
- x_82 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_82 = x_80;
-}
-lean_ctor_set(x_82, 0, x_33);
-lean_ctor_set(x_82, 1, x_34);
-lean_ctor_set(x_82, 2, x_35);
-lean_ctor_set(x_82, 3, x_44);
-lean_ctor_set_uint8(x_82, sizeof(void*)*4, x_81);
-x_83 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_83, 0, x_76);
-lean_ctor_set(x_83, 1, x_77);
-lean_ctor_set(x_83, 2, x_78);
-lean_ctor_set(x_83, 3, x_79);
-lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_81);
-lean_ctor_set(x_2, 3, x_83);
-lean_ctor_set(x_2, 2, x_75);
-lean_ctor_set(x_2, 1, x_74);
-lean_ctor_set(x_2, 0, x_82);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_56);
-return x_2;
-}
-}
-else
-{
-uint8_t x_84; 
-x_84 = !lean_is_exclusive(x_43);
-if (x_84 == 0)
-{
-lean_object* x_85; lean_object* x_86; uint8_t x_87; 
-x_85 = lean_ctor_get(x_43, 3);
-lean_dec(x_85);
-x_86 = lean_ctor_get(x_43, 0);
-lean_dec(x_86);
-x_87 = 0;
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_87);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_56);
-return x_2;
-}
-else
-{
-lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; 
-x_88 = lean_ctor_get(x_43, 1);
-x_89 = lean_ctor_get(x_43, 2);
-lean_inc(x_89);
-lean_inc(x_88);
-lean_dec(x_43);
-x_90 = 0;
-x_91 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_91, 0, x_44);
-lean_ctor_set(x_91, 1, x_88);
-lean_ctor_set(x_91, 2, x_89);
-lean_ctor_set(x_91, 3, x_45);
-lean_ctor_set_uint8(x_91, sizeof(void*)*4, x_90);
-lean_ctor_set(x_2, 3, x_91);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_56);
-return x_2;
-}
-}
-}
-}
-else
-{
-uint8_t x_92; 
-x_92 = lean_ctor_get_uint8(x_44, sizeof(void*)*4);
-if (x_92 == 0)
-{
-uint8_t x_93; 
-x_93 = !lean_is_exclusive(x_43);
-if (x_93 == 0)
-{
-lean_object* x_94; uint8_t x_95; 
-x_94 = lean_ctor_get(x_43, 0);
-lean_dec(x_94);
-x_95 = !lean_is_exclusive(x_44);
-if (x_95 == 0)
-{
-lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; 
-x_96 = lean_ctor_get(x_44, 0);
-x_97 = lean_ctor_get(x_44, 1);
-x_98 = lean_ctor_get(x_44, 2);
-x_99 = lean_ctor_get(x_44, 3);
-x_100 = 1;
-lean_ctor_set(x_44, 3, x_96);
-lean_ctor_set(x_44, 2, x_35);
-lean_ctor_set(x_44, 1, x_34);
-lean_ctor_set(x_44, 0, x_33);
-lean_ctor_set_uint8(x_44, sizeof(void*)*4, x_100);
-lean_ctor_set(x_43, 0, x_99);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_100);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set(x_2, 2, x_98);
-lean_ctor_set(x_2, 1, x_97);
-lean_ctor_set(x_2, 0, x_44);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_92);
-return x_2;
-}
-else
-{
-lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; uint8_t x_105; lean_object* x_106; 
-x_101 = lean_ctor_get(x_44, 0);
-x_102 = lean_ctor_get(x_44, 1);
-x_103 = lean_ctor_get(x_44, 2);
-x_104 = lean_ctor_get(x_44, 3);
-lean_inc(x_104);
-lean_inc(x_103);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_dec(x_44);
-x_105 = 1;
-x_106 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_106, 0, x_33);
-lean_ctor_set(x_106, 1, x_34);
-lean_ctor_set(x_106, 2, x_35);
-lean_ctor_set(x_106, 3, x_101);
-lean_ctor_set_uint8(x_106, sizeof(void*)*4, x_105);
-lean_ctor_set(x_43, 0, x_104);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_105);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set(x_2, 2, x_103);
-lean_ctor_set(x_2, 1, x_102);
-lean_ctor_set(x_2, 0, x_106);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_92);
-return x_2;
-}
-}
-else
-{
-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; uint8_t x_115; lean_object* x_116; lean_object* x_117; 
-x_107 = lean_ctor_get(x_43, 1);
-x_108 = lean_ctor_get(x_43, 2);
-x_109 = lean_ctor_get(x_43, 3);
-lean_inc(x_109);
-lean_inc(x_108);
-lean_inc(x_107);
-lean_dec(x_43);
-x_110 = lean_ctor_get(x_44, 0);
-lean_inc(x_110);
-x_111 = lean_ctor_get(x_44, 1);
-lean_inc(x_111);
-x_112 = lean_ctor_get(x_44, 2);
-lean_inc(x_112);
-x_113 = lean_ctor_get(x_44, 3);
-lean_inc(x_113);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- lean_ctor_release(x_44, 1);
- lean_ctor_release(x_44, 2);
- lean_ctor_release(x_44, 3);
- x_114 = x_44;
-} else {
- lean_dec_ref(x_44);
- x_114 = lean_box(0);
-}
-x_115 = 1;
-if (lean_is_scalar(x_114)) {
- x_116 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_116 = x_114;
-}
-lean_ctor_set(x_116, 0, x_33);
-lean_ctor_set(x_116, 1, x_34);
-lean_ctor_set(x_116, 2, x_35);
-lean_ctor_set(x_116, 3, x_110);
-lean_ctor_set_uint8(x_116, sizeof(void*)*4, x_115);
-x_117 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_117, 0, x_113);
-lean_ctor_set(x_117, 1, x_107);
-lean_ctor_set(x_117, 2, x_108);
-lean_ctor_set(x_117, 3, x_109);
-lean_ctor_set_uint8(x_117, sizeof(void*)*4, x_115);
-lean_ctor_set(x_2, 3, x_117);
-lean_ctor_set(x_2, 2, x_112);
-lean_ctor_set(x_2, 1, x_111);
-lean_ctor_set(x_2, 0, x_116);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_92);
-return x_2;
-}
-}
-else
-{
-lean_object* x_118; 
-x_118 = lean_ctor_get(x_43, 3);
-lean_inc(x_118);
-if (lean_obj_tag(x_118) == 0)
-{
-uint8_t x_119; 
-x_119 = !lean_is_exclusive(x_43);
-if (x_119 == 0)
-{
-lean_object* x_120; lean_object* x_121; uint8_t x_122; 
-x_120 = lean_ctor_get(x_43, 3);
-lean_dec(x_120);
-x_121 = lean_ctor_get(x_43, 0);
-lean_dec(x_121);
-x_122 = 0;
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_122);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_92);
-return x_2;
-}
-else
-{
-lean_object* x_123; lean_object* x_124; uint8_t x_125; lean_object* x_126; 
-x_123 = lean_ctor_get(x_43, 1);
-x_124 = lean_ctor_get(x_43, 2);
-lean_inc(x_124);
-lean_inc(x_123);
-lean_dec(x_43);
-x_125 = 0;
-x_126 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_126, 0, x_44);
-lean_ctor_set(x_126, 1, x_123);
-lean_ctor_set(x_126, 2, x_124);
-lean_ctor_set(x_126, 3, x_118);
-lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_125);
-lean_ctor_set(x_2, 3, x_126);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_92);
-return x_2;
-}
-}
-else
-{
-uint8_t x_127; 
-x_127 = lean_ctor_get_uint8(x_118, sizeof(void*)*4);
-if (x_127 == 0)
-{
-uint8_t x_128; 
-lean_free_object(x_2);
-x_128 = !lean_is_exclusive(x_43);
-if (x_128 == 0)
-{
-lean_object* x_129; lean_object* x_130; uint8_t x_131; 
-x_129 = lean_ctor_get(x_43, 3);
-lean_dec(x_129);
-x_130 = lean_ctor_get(x_43, 0);
-lean_dec(x_130);
-x_131 = !lean_is_exclusive(x_118);
-if (x_131 == 0)
-{
-lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; 
-x_132 = lean_ctor_get(x_118, 0);
-x_133 = lean_ctor_get(x_118, 1);
-x_134 = lean_ctor_get(x_118, 2);
-x_135 = lean_ctor_get(x_118, 3);
-lean_inc(x_44);
-lean_ctor_set(x_118, 3, x_44);
-lean_ctor_set(x_118, 2, x_35);
-lean_ctor_set(x_118, 1, x_34);
-lean_ctor_set(x_118, 0, x_33);
-x_136 = !lean_is_exclusive(x_44);
-if (x_136 == 0)
-{
-lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; 
-x_137 = lean_ctor_get(x_44, 3);
-lean_dec(x_137);
-x_138 = lean_ctor_get(x_44, 2);
-lean_dec(x_138);
-x_139 = lean_ctor_get(x_44, 1);
-lean_dec(x_139);
-x_140 = lean_ctor_get(x_44, 0);
-lean_dec(x_140);
-lean_ctor_set_uint8(x_118, sizeof(void*)*4, x_92);
-lean_ctor_set(x_44, 3, x_135);
-lean_ctor_set(x_44, 2, x_134);
-lean_ctor_set(x_44, 1, x_133);
-lean_ctor_set(x_44, 0, x_132);
-lean_ctor_set(x_43, 3, x_44);
-lean_ctor_set(x_43, 0, x_118);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_127);
-return x_43;
-}
-else
-{
-lean_object* x_141; 
-lean_dec(x_44);
-lean_ctor_set_uint8(x_118, sizeof(void*)*4, x_92);
-x_141 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_141, 0, x_132);
-lean_ctor_set(x_141, 1, x_133);
-lean_ctor_set(x_141, 2, x_134);
-lean_ctor_set(x_141, 3, x_135);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_92);
-lean_ctor_set(x_43, 3, x_141);
-lean_ctor_set(x_43, 0, x_118);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_127);
-return x_43;
-}
-}
-else
-{
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; 
-x_142 = lean_ctor_get(x_118, 0);
-x_143 = lean_ctor_get(x_118, 1);
-x_144 = lean_ctor_get(x_118, 2);
-x_145 = lean_ctor_get(x_118, 3);
-lean_inc(x_145);
-lean_inc(x_144);
-lean_inc(x_143);
-lean_inc(x_142);
-lean_dec(x_118);
-lean_inc(x_44);
-x_146 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_146, 0, x_33);
-lean_ctor_set(x_146, 1, x_34);
-lean_ctor_set(x_146, 2, x_35);
-lean_ctor_set(x_146, 3, x_44);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- lean_ctor_release(x_44, 1);
- lean_ctor_release(x_44, 2);
- lean_ctor_release(x_44, 3);
- x_147 = x_44;
-} else {
- lean_dec_ref(x_44);
- x_147 = lean_box(0);
-}
-lean_ctor_set_uint8(x_146, sizeof(void*)*4, x_92);
-if (lean_is_scalar(x_147)) {
- x_148 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_148 = x_147;
-}
-lean_ctor_set(x_148, 0, x_142);
-lean_ctor_set(x_148, 1, x_143);
-lean_ctor_set(x_148, 2, x_144);
-lean_ctor_set(x_148, 3, x_145);
-lean_ctor_set_uint8(x_148, sizeof(void*)*4, x_92);
-lean_ctor_set(x_43, 3, x_148);
-lean_ctor_set(x_43, 0, x_146);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_127);
-return x_43;
-}
-}
-else
-{
-lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; 
-x_149 = lean_ctor_get(x_43, 1);
-x_150 = lean_ctor_get(x_43, 2);
-lean_inc(x_150);
-lean_inc(x_149);
-lean_dec(x_43);
-x_151 = lean_ctor_get(x_118, 0);
-lean_inc(x_151);
-x_152 = lean_ctor_get(x_118, 1);
-lean_inc(x_152);
-x_153 = lean_ctor_get(x_118, 2);
-lean_inc(x_153);
-x_154 = lean_ctor_get(x_118, 3);
-lean_inc(x_154);
-if (lean_is_exclusive(x_118)) {
- lean_ctor_release(x_118, 0);
- lean_ctor_release(x_118, 1);
- lean_ctor_release(x_118, 2);
- lean_ctor_release(x_118, 3);
- x_155 = x_118;
-} else {
- lean_dec_ref(x_118);
- x_155 = lean_box(0);
-}
-lean_inc(x_44);
-if (lean_is_scalar(x_155)) {
- x_156 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_156 = x_155;
-}
-lean_ctor_set(x_156, 0, x_33);
-lean_ctor_set(x_156, 1, x_34);
-lean_ctor_set(x_156, 2, x_35);
-lean_ctor_set(x_156, 3, x_44);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- lean_ctor_release(x_44, 1);
- lean_ctor_release(x_44, 2);
- lean_ctor_release(x_44, 3);
- x_157 = x_44;
-} else {
- lean_dec_ref(x_44);
- x_157 = lean_box(0);
-}
-lean_ctor_set_uint8(x_156, sizeof(void*)*4, x_92);
-if (lean_is_scalar(x_157)) {
- x_158 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_158 = x_157;
-}
-lean_ctor_set(x_158, 0, x_151);
-lean_ctor_set(x_158, 1, x_152);
-lean_ctor_set(x_158, 2, x_153);
-lean_ctor_set(x_158, 3, x_154);
-lean_ctor_set_uint8(x_158, sizeof(void*)*4, x_92);
-x_159 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_159, 0, x_156);
-lean_ctor_set(x_159, 1, x_149);
-lean_ctor_set(x_159, 2, x_150);
-lean_ctor_set(x_159, 3, x_158);
-lean_ctor_set_uint8(x_159, sizeof(void*)*4, x_127);
-return x_159;
-}
-}
-else
-{
-uint8_t x_160; 
-x_160 = !lean_is_exclusive(x_43);
-if (x_160 == 0)
-{
-lean_object* x_161; lean_object* x_162; uint8_t x_163; 
-x_161 = lean_ctor_get(x_43, 3);
-lean_dec(x_161);
-x_162 = lean_ctor_get(x_43, 0);
-lean_dec(x_162);
-x_163 = !lean_is_exclusive(x_44);
-if (x_163 == 0)
-{
-uint8_t x_164; 
-lean_ctor_set_uint8(x_44, sizeof(void*)*4, x_127);
-x_164 = 0;
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_164);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_127);
-return x_2;
-}
-else
-{
-lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; uint8_t x_170; 
-x_165 = lean_ctor_get(x_44, 0);
-x_166 = lean_ctor_get(x_44, 1);
-x_167 = lean_ctor_get(x_44, 2);
-x_168 = lean_ctor_get(x_44, 3);
-lean_inc(x_168);
-lean_inc(x_167);
-lean_inc(x_166);
-lean_inc(x_165);
-lean_dec(x_44);
-x_169 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_169, 0, x_165);
-lean_ctor_set(x_169, 1, x_166);
-lean_ctor_set(x_169, 2, x_167);
-lean_ctor_set(x_169, 3, x_168);
-lean_ctor_set_uint8(x_169, sizeof(void*)*4, x_127);
-x_170 = 0;
-lean_ctor_set(x_43, 0, x_169);
-lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_170);
-lean_ctor_set(x_2, 3, x_43);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_127);
-return x_2;
-}
-}
-else
-{
-lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; uint8_t x_179; lean_object* x_180; 
-x_171 = lean_ctor_get(x_43, 1);
-x_172 = lean_ctor_get(x_43, 2);
-lean_inc(x_172);
-lean_inc(x_171);
-lean_dec(x_43);
-x_173 = lean_ctor_get(x_44, 0);
-lean_inc(x_173);
-x_174 = lean_ctor_get(x_44, 1);
-lean_inc(x_174);
-x_175 = lean_ctor_get(x_44, 2);
-lean_inc(x_175);
-x_176 = lean_ctor_get(x_44, 3);
-lean_inc(x_176);
-if (lean_is_exclusive(x_44)) {
- lean_ctor_release(x_44, 0);
- lean_ctor_release(x_44, 1);
- lean_ctor_release(x_44, 2);
- lean_ctor_release(x_44, 3);
- x_177 = x_44;
-} else {
- lean_dec_ref(x_44);
- x_177 = lean_box(0);
-}
-if (lean_is_scalar(x_177)) {
- x_178 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_178 = x_177;
-}
-lean_ctor_set(x_178, 0, x_173);
-lean_ctor_set(x_178, 1, x_174);
-lean_ctor_set(x_178, 2, x_175);
-lean_ctor_set(x_178, 3, x_176);
-lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_127);
-x_179 = 0;
-x_180 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_180, 0, x_178);
-lean_ctor_set(x_180, 1, x_171);
-lean_ctor_set(x_180, 2, x_172);
-lean_ctor_set(x_180, 3, x_118);
-lean_ctor_set_uint8(x_180, sizeof(void*)*4, x_179);
-lean_ctor_set(x_2, 3, x_180);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_127);
-return x_2;
-}
-}
-}
-}
-}
-}
-}
-}
-else
-{
-uint8_t x_181; 
-x_181 = l_Std_RBNode_isRed___rarg(x_33);
-if (x_181 == 0)
-{
-lean_object* x_182; 
-x_182 = l_Std_RBNode_ins___main___rarg(x_1, x_33, x_3, x_4);
-lean_ctor_set(x_2, 0, x_182);
-return x_2;
-}
-else
-{
-lean_object* x_183; lean_object* x_184; 
-x_183 = l_Std_RBNode_ins___main___rarg(x_1, x_33, x_3, x_4);
-x_184 = lean_ctor_get(x_183, 0);
-lean_inc(x_184);
-if (lean_obj_tag(x_184) == 0)
-{
-lean_object* x_185; 
-x_185 = lean_ctor_get(x_183, 3);
-lean_inc(x_185);
-if (lean_obj_tag(x_185) == 0)
-{
-uint8_t x_186; 
-x_186 = !lean_is_exclusive(x_183);
-if (x_186 == 0)
-{
-lean_object* x_187; lean_object* x_188; uint8_t x_189; uint8_t x_190; 
-x_187 = lean_ctor_get(x_183, 3);
-lean_dec(x_187);
-x_188 = lean_ctor_get(x_183, 0);
-lean_dec(x_188);
-x_189 = 0;
-lean_ctor_set(x_183, 0, x_185);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_189);
-x_190 = 1;
-lean_ctor_set(x_2, 0, x_183);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_190);
-return x_2;
-}
-else
-{
-lean_object* x_191; lean_object* x_192; uint8_t x_193; lean_object* x_194; uint8_t x_195; 
-x_191 = lean_ctor_get(x_183, 1);
-x_192 = lean_ctor_get(x_183, 2);
-lean_inc(x_192);
-lean_inc(x_191);
-lean_dec(x_183);
-x_193 = 0;
-x_194 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_194, 0, x_185);
-lean_ctor_set(x_194, 1, x_191);
-lean_ctor_set(x_194, 2, x_192);
-lean_ctor_set(x_194, 3, x_185);
-lean_ctor_set_uint8(x_194, sizeof(void*)*4, x_193);
-x_195 = 1;
-lean_ctor_set(x_2, 0, x_194);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_195);
-return x_2;
-}
-}
-else
-{
-uint8_t x_196; 
-x_196 = lean_ctor_get_uint8(x_185, sizeof(void*)*4);
-if (x_196 == 0)
-{
-uint8_t x_197; 
-x_197 = !lean_is_exclusive(x_183);
-if (x_197 == 0)
-{
-lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; uint8_t x_202; 
-x_198 = lean_ctor_get(x_183, 1);
-x_199 = lean_ctor_get(x_183, 2);
-x_200 = lean_ctor_get(x_183, 3);
-lean_dec(x_200);
-x_201 = lean_ctor_get(x_183, 0);
-lean_dec(x_201);
-x_202 = !lean_is_exclusive(x_185);
-if (x_202 == 0)
-{
-lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; uint8_t x_207; 
-x_203 = lean_ctor_get(x_185, 0);
-x_204 = lean_ctor_get(x_185, 1);
-x_205 = lean_ctor_get(x_185, 2);
-x_206 = lean_ctor_get(x_185, 3);
-x_207 = 1;
-lean_ctor_set(x_185, 3, x_203);
-lean_ctor_set(x_185, 2, x_199);
-lean_ctor_set(x_185, 1, x_198);
-lean_ctor_set(x_185, 0, x_184);
-lean_ctor_set_uint8(x_185, sizeof(void*)*4, x_207);
-lean_ctor_set(x_183, 3, x_36);
-lean_ctor_set(x_183, 2, x_35);
-lean_ctor_set(x_183, 1, x_34);
-lean_ctor_set(x_183, 0, x_206);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_207);
-lean_ctor_set(x_2, 3, x_183);
-lean_ctor_set(x_2, 2, x_205);
-lean_ctor_set(x_2, 1, x_204);
-lean_ctor_set(x_2, 0, x_185);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_196);
-return x_2;
-}
-else
-{
-lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; uint8_t x_212; lean_object* x_213; 
-x_208 = lean_ctor_get(x_185, 0);
-x_209 = lean_ctor_get(x_185, 1);
-x_210 = lean_ctor_get(x_185, 2);
-x_211 = lean_ctor_get(x_185, 3);
-lean_inc(x_211);
-lean_inc(x_210);
-lean_inc(x_209);
-lean_inc(x_208);
-lean_dec(x_185);
-x_212 = 1;
-x_213 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_213, 0, x_184);
-lean_ctor_set(x_213, 1, x_198);
-lean_ctor_set(x_213, 2, x_199);
-lean_ctor_set(x_213, 3, x_208);
-lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_212);
-lean_ctor_set(x_183, 3, x_36);
-lean_ctor_set(x_183, 2, x_35);
-lean_ctor_set(x_183, 1, x_34);
-lean_ctor_set(x_183, 0, x_211);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_212);
-lean_ctor_set(x_2, 3, x_183);
-lean_ctor_set(x_2, 2, x_210);
-lean_ctor_set(x_2, 1, x_209);
-lean_ctor_set(x_2, 0, x_213);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_196);
-return x_2;
-}
-}
-else
-{
-lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; uint8_t x_221; lean_object* x_222; lean_object* x_223; 
-x_214 = lean_ctor_get(x_183, 1);
-x_215 = lean_ctor_get(x_183, 2);
-lean_inc(x_215);
-lean_inc(x_214);
-lean_dec(x_183);
-x_216 = lean_ctor_get(x_185, 0);
-lean_inc(x_216);
-x_217 = lean_ctor_get(x_185, 1);
-lean_inc(x_217);
-x_218 = lean_ctor_get(x_185, 2);
-lean_inc(x_218);
-x_219 = lean_ctor_get(x_185, 3);
-lean_inc(x_219);
-if (lean_is_exclusive(x_185)) {
- lean_ctor_release(x_185, 0);
- lean_ctor_release(x_185, 1);
- lean_ctor_release(x_185, 2);
- lean_ctor_release(x_185, 3);
- x_220 = x_185;
-} else {
- lean_dec_ref(x_185);
- x_220 = lean_box(0);
-}
-x_221 = 1;
-if (lean_is_scalar(x_220)) {
- x_222 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_222 = x_220;
-}
-lean_ctor_set(x_222, 0, x_184);
-lean_ctor_set(x_222, 1, x_214);
-lean_ctor_set(x_222, 2, x_215);
-lean_ctor_set(x_222, 3, x_216);
-lean_ctor_set_uint8(x_222, sizeof(void*)*4, x_221);
-x_223 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_223, 0, x_219);
-lean_ctor_set(x_223, 1, x_34);
-lean_ctor_set(x_223, 2, x_35);
-lean_ctor_set(x_223, 3, x_36);
-lean_ctor_set_uint8(x_223, sizeof(void*)*4, x_221);
-lean_ctor_set(x_2, 3, x_223);
-lean_ctor_set(x_2, 2, x_218);
-lean_ctor_set(x_2, 1, x_217);
-lean_ctor_set(x_2, 0, x_222);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_196);
-return x_2;
-}
-}
-else
-{
-uint8_t x_224; 
-x_224 = !lean_is_exclusive(x_183);
-if (x_224 == 0)
-{
-lean_object* x_225; lean_object* x_226; uint8_t x_227; 
-x_225 = lean_ctor_get(x_183, 3);
-lean_dec(x_225);
-x_226 = lean_ctor_get(x_183, 0);
-lean_dec(x_226);
-x_227 = 0;
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_227);
-lean_ctor_set(x_2, 0, x_183);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_196);
-return x_2;
-}
-else
-{
-lean_object* x_228; lean_object* x_229; uint8_t x_230; lean_object* x_231; 
-x_228 = lean_ctor_get(x_183, 1);
-x_229 = lean_ctor_get(x_183, 2);
-lean_inc(x_229);
-lean_inc(x_228);
-lean_dec(x_183);
-x_230 = 0;
-x_231 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_231, 0, x_184);
-lean_ctor_set(x_231, 1, x_228);
-lean_ctor_set(x_231, 2, x_229);
-lean_ctor_set(x_231, 3, x_185);
-lean_ctor_set_uint8(x_231, sizeof(void*)*4, x_230);
-lean_ctor_set(x_2, 0, x_231);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_196);
-return x_2;
-}
-}
-}
-}
-else
-{
-uint8_t x_232; 
-x_232 = lean_ctor_get_uint8(x_184, sizeof(void*)*4);
-if (x_232 == 0)
-{
-uint8_t x_233; 
-x_233 = !lean_is_exclusive(x_183);
-if (x_233 == 0)
-{
-lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; uint8_t x_238; 
-x_234 = lean_ctor_get(x_183, 1);
-x_235 = lean_ctor_get(x_183, 2);
-x_236 = lean_ctor_get(x_183, 3);
-x_237 = lean_ctor_get(x_183, 0);
-lean_dec(x_237);
-x_238 = !lean_is_exclusive(x_184);
-if (x_238 == 0)
-{
-uint8_t x_239; 
-x_239 = 1;
-lean_ctor_set_uint8(x_184, sizeof(void*)*4, x_239);
-lean_ctor_set(x_183, 3, x_36);
-lean_ctor_set(x_183, 2, x_35);
-lean_ctor_set(x_183, 1, x_34);
-lean_ctor_set(x_183, 0, x_236);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_239);
-lean_ctor_set(x_2, 3, x_183);
-lean_ctor_set(x_2, 2, x_235);
-lean_ctor_set(x_2, 1, x_234);
-lean_ctor_set(x_2, 0, x_184);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_232);
-return x_2;
-}
-else
-{
-lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; lean_object* x_245; 
-x_240 = lean_ctor_get(x_184, 0);
-x_241 = lean_ctor_get(x_184, 1);
-x_242 = lean_ctor_get(x_184, 2);
-x_243 = lean_ctor_get(x_184, 3);
-lean_inc(x_243);
-lean_inc(x_242);
-lean_inc(x_241);
-lean_inc(x_240);
-lean_dec(x_184);
-x_244 = 1;
-x_245 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_245, 0, x_240);
-lean_ctor_set(x_245, 1, x_241);
-lean_ctor_set(x_245, 2, x_242);
-lean_ctor_set(x_245, 3, x_243);
-lean_ctor_set_uint8(x_245, sizeof(void*)*4, x_244);
-lean_ctor_set(x_183, 3, x_36);
-lean_ctor_set(x_183, 2, x_35);
-lean_ctor_set(x_183, 1, x_34);
-lean_ctor_set(x_183, 0, x_236);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_244);
-lean_ctor_set(x_2, 3, x_183);
-lean_ctor_set(x_2, 2, x_235);
-lean_ctor_set(x_2, 1, x_234);
-lean_ctor_set(x_2, 0, x_245);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_232);
-return x_2;
-}
-}
-else
-{
-lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; uint8_t x_254; lean_object* x_255; lean_object* x_256; 
-x_246 = lean_ctor_get(x_183, 1);
-x_247 = lean_ctor_get(x_183, 2);
-x_248 = lean_ctor_get(x_183, 3);
-lean_inc(x_248);
-lean_inc(x_247);
-lean_inc(x_246);
-lean_dec(x_183);
-x_249 = lean_ctor_get(x_184, 0);
-lean_inc(x_249);
-x_250 = lean_ctor_get(x_184, 1);
-lean_inc(x_250);
-x_251 = lean_ctor_get(x_184, 2);
-lean_inc(x_251);
-x_252 = lean_ctor_get(x_184, 3);
-lean_inc(x_252);
-if (lean_is_exclusive(x_184)) {
- lean_ctor_release(x_184, 0);
- lean_ctor_release(x_184, 1);
- lean_ctor_release(x_184, 2);
- lean_ctor_release(x_184, 3);
- x_253 = x_184;
-} else {
- lean_dec_ref(x_184);
- x_253 = lean_box(0);
-}
-x_254 = 1;
-if (lean_is_scalar(x_253)) {
- x_255 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_255 = x_253;
-}
-lean_ctor_set(x_255, 0, x_249);
-lean_ctor_set(x_255, 1, x_250);
-lean_ctor_set(x_255, 2, x_251);
-lean_ctor_set(x_255, 3, x_252);
-lean_ctor_set_uint8(x_255, sizeof(void*)*4, x_254);
-x_256 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_256, 0, x_248);
-lean_ctor_set(x_256, 1, x_34);
-lean_ctor_set(x_256, 2, x_35);
-lean_ctor_set(x_256, 3, x_36);
-lean_ctor_set_uint8(x_256, sizeof(void*)*4, x_254);
-lean_ctor_set(x_2, 3, x_256);
-lean_ctor_set(x_2, 2, x_247);
-lean_ctor_set(x_2, 1, x_246);
-lean_ctor_set(x_2, 0, x_255);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_232);
-return x_2;
-}
-}
-else
-{
-lean_object* x_257; 
-x_257 = lean_ctor_get(x_183, 3);
-lean_inc(x_257);
-if (lean_obj_tag(x_257) == 0)
-{
-uint8_t x_258; 
-x_258 = !lean_is_exclusive(x_183);
-if (x_258 == 0)
-{
-lean_object* x_259; lean_object* x_260; uint8_t x_261; 
-x_259 = lean_ctor_get(x_183, 3);
-lean_dec(x_259);
-x_260 = lean_ctor_get(x_183, 0);
-lean_dec(x_260);
-x_261 = 0;
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_261);
-lean_ctor_set(x_2, 0, x_183);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_232);
-return x_2;
-}
-else
-{
-lean_object* x_262; lean_object* x_263; uint8_t x_264; lean_object* x_265; 
-x_262 = lean_ctor_get(x_183, 1);
-x_263 = lean_ctor_get(x_183, 2);
-lean_inc(x_263);
-lean_inc(x_262);
-lean_dec(x_183);
-x_264 = 0;
-x_265 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_265, 0, x_184);
-lean_ctor_set(x_265, 1, x_262);
-lean_ctor_set(x_265, 2, x_263);
-lean_ctor_set(x_265, 3, x_257);
-lean_ctor_set_uint8(x_265, sizeof(void*)*4, x_264);
-lean_ctor_set(x_2, 0, x_265);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_232);
-return x_2;
-}
-}
-else
-{
-uint8_t x_266; 
-x_266 = lean_ctor_get_uint8(x_257, sizeof(void*)*4);
-if (x_266 == 0)
-{
-uint8_t x_267; 
-lean_free_object(x_2);
-x_267 = !lean_is_exclusive(x_183);
-if (x_267 == 0)
-{
-lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; uint8_t x_272; 
-x_268 = lean_ctor_get(x_183, 1);
-x_269 = lean_ctor_get(x_183, 2);
-x_270 = lean_ctor_get(x_183, 3);
-lean_dec(x_270);
-x_271 = lean_ctor_get(x_183, 0);
-lean_dec(x_271);
-x_272 = !lean_is_exclusive(x_257);
-if (x_272 == 0)
-{
-lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; uint8_t x_277; 
-x_273 = lean_ctor_get(x_257, 0);
-x_274 = lean_ctor_get(x_257, 1);
-x_275 = lean_ctor_get(x_257, 2);
-x_276 = lean_ctor_get(x_257, 3);
-lean_inc(x_184);
-lean_ctor_set(x_257, 3, x_273);
-lean_ctor_set(x_257, 2, x_269);
-lean_ctor_set(x_257, 1, x_268);
-lean_ctor_set(x_257, 0, x_184);
-x_277 = !lean_is_exclusive(x_184);
-if (x_277 == 0)
-{
-lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; 
-x_278 = lean_ctor_get(x_184, 3);
-lean_dec(x_278);
-x_279 = lean_ctor_get(x_184, 2);
-lean_dec(x_279);
-x_280 = lean_ctor_get(x_184, 1);
-lean_dec(x_280);
-x_281 = lean_ctor_get(x_184, 0);
-lean_dec(x_281);
-lean_ctor_set_uint8(x_257, sizeof(void*)*4, x_232);
-lean_ctor_set(x_184, 3, x_36);
-lean_ctor_set(x_184, 2, x_35);
-lean_ctor_set(x_184, 1, x_34);
-lean_ctor_set(x_184, 0, x_276);
-lean_ctor_set(x_183, 3, x_184);
-lean_ctor_set(x_183, 2, x_275);
-lean_ctor_set(x_183, 1, x_274);
-lean_ctor_set(x_183, 0, x_257);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_266);
-return x_183;
-}
-else
-{
-lean_object* x_282; 
-lean_dec(x_184);
-lean_ctor_set_uint8(x_257, sizeof(void*)*4, x_232);
-x_282 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_282, 0, x_276);
-lean_ctor_set(x_282, 1, x_34);
-lean_ctor_set(x_282, 2, x_35);
-lean_ctor_set(x_282, 3, x_36);
-lean_ctor_set_uint8(x_282, sizeof(void*)*4, x_232);
-lean_ctor_set(x_183, 3, x_282);
-lean_ctor_set(x_183, 2, x_275);
-lean_ctor_set(x_183, 1, x_274);
-lean_ctor_set(x_183, 0, x_257);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_266);
-return x_183;
-}
-}
-else
-{
-lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; 
-x_283 = lean_ctor_get(x_257, 0);
-x_284 = lean_ctor_get(x_257, 1);
-x_285 = lean_ctor_get(x_257, 2);
-x_286 = lean_ctor_get(x_257, 3);
-lean_inc(x_286);
-lean_inc(x_285);
-lean_inc(x_284);
-lean_inc(x_283);
-lean_dec(x_257);
-lean_inc(x_184);
-x_287 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_287, 0, x_184);
-lean_ctor_set(x_287, 1, x_268);
-lean_ctor_set(x_287, 2, x_269);
-lean_ctor_set(x_287, 3, x_283);
-if (lean_is_exclusive(x_184)) {
- lean_ctor_release(x_184, 0);
- lean_ctor_release(x_184, 1);
- lean_ctor_release(x_184, 2);
- lean_ctor_release(x_184, 3);
- x_288 = x_184;
-} else {
- lean_dec_ref(x_184);
- x_288 = lean_box(0);
-}
-lean_ctor_set_uint8(x_287, sizeof(void*)*4, x_232);
-if (lean_is_scalar(x_288)) {
- x_289 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_289 = x_288;
-}
-lean_ctor_set(x_289, 0, x_286);
-lean_ctor_set(x_289, 1, x_34);
-lean_ctor_set(x_289, 2, x_35);
-lean_ctor_set(x_289, 3, x_36);
-lean_ctor_set_uint8(x_289, sizeof(void*)*4, x_232);
-lean_ctor_set(x_183, 3, x_289);
-lean_ctor_set(x_183, 2, x_285);
-lean_ctor_set(x_183, 1, x_284);
-lean_ctor_set(x_183, 0, x_287);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_266);
-return x_183;
-}
-}
-else
-{
-lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; lean_object* x_300; 
-x_290 = lean_ctor_get(x_183, 1);
-x_291 = lean_ctor_get(x_183, 2);
-lean_inc(x_291);
-lean_inc(x_290);
-lean_dec(x_183);
-x_292 = lean_ctor_get(x_257, 0);
-lean_inc(x_292);
-x_293 = lean_ctor_get(x_257, 1);
-lean_inc(x_293);
-x_294 = lean_ctor_get(x_257, 2);
-lean_inc(x_294);
-x_295 = lean_ctor_get(x_257, 3);
-lean_inc(x_295);
-if (lean_is_exclusive(x_257)) {
- lean_ctor_release(x_257, 0);
- lean_ctor_release(x_257, 1);
- lean_ctor_release(x_257, 2);
- lean_ctor_release(x_257, 3);
- x_296 = x_257;
-} else {
- lean_dec_ref(x_257);
- x_296 = lean_box(0);
-}
-lean_inc(x_184);
-if (lean_is_scalar(x_296)) {
- x_297 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_297 = x_296;
-}
-lean_ctor_set(x_297, 0, x_184);
-lean_ctor_set(x_297, 1, x_290);
-lean_ctor_set(x_297, 2, x_291);
-lean_ctor_set(x_297, 3, x_292);
-if (lean_is_exclusive(x_184)) {
- lean_ctor_release(x_184, 0);
- lean_ctor_release(x_184, 1);
- lean_ctor_release(x_184, 2);
- lean_ctor_release(x_184, 3);
- x_298 = x_184;
-} else {
- lean_dec_ref(x_184);
- x_298 = lean_box(0);
-}
-lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_232);
-if (lean_is_scalar(x_298)) {
- x_299 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_299 = x_298;
-}
-lean_ctor_set(x_299, 0, x_295);
-lean_ctor_set(x_299, 1, x_34);
-lean_ctor_set(x_299, 2, x_35);
-lean_ctor_set(x_299, 3, x_36);
-lean_ctor_set_uint8(x_299, sizeof(void*)*4, x_232);
-x_300 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_300, 0, x_297);
-lean_ctor_set(x_300, 1, x_293);
-lean_ctor_set(x_300, 2, x_294);
-lean_ctor_set(x_300, 3, x_299);
-lean_ctor_set_uint8(x_300, sizeof(void*)*4, x_266);
-return x_300;
-}
-}
-else
-{
-uint8_t x_301; 
-x_301 = !lean_is_exclusive(x_183);
-if (x_301 == 0)
-{
-lean_object* x_302; lean_object* x_303; uint8_t x_304; 
-x_302 = lean_ctor_get(x_183, 3);
-lean_dec(x_302);
-x_303 = lean_ctor_get(x_183, 0);
-lean_dec(x_303);
-x_304 = !lean_is_exclusive(x_184);
-if (x_304 == 0)
-{
-uint8_t x_305; 
-lean_ctor_set_uint8(x_184, sizeof(void*)*4, x_266);
-x_305 = 0;
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_305);
-lean_ctor_set(x_2, 0, x_183);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_266);
-return x_2;
-}
-else
-{
-lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; lean_object* x_310; uint8_t x_311; 
-x_306 = lean_ctor_get(x_184, 0);
-x_307 = lean_ctor_get(x_184, 1);
-x_308 = lean_ctor_get(x_184, 2);
-x_309 = lean_ctor_get(x_184, 3);
-lean_inc(x_309);
-lean_inc(x_308);
-lean_inc(x_307);
-lean_inc(x_306);
-lean_dec(x_184);
-x_310 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_310, 0, x_306);
-lean_ctor_set(x_310, 1, x_307);
-lean_ctor_set(x_310, 2, x_308);
-lean_ctor_set(x_310, 3, x_309);
-lean_ctor_set_uint8(x_310, sizeof(void*)*4, x_266);
-x_311 = 0;
-lean_ctor_set(x_183, 0, x_310);
-lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_311);
-lean_ctor_set(x_2, 0, x_183);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_266);
-return x_2;
-}
-}
-else
-{
-lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; uint8_t x_320; lean_object* x_321; 
-x_312 = lean_ctor_get(x_183, 1);
-x_313 = lean_ctor_get(x_183, 2);
-lean_inc(x_313);
-lean_inc(x_312);
-lean_dec(x_183);
-x_314 = lean_ctor_get(x_184, 0);
-lean_inc(x_314);
-x_315 = lean_ctor_get(x_184, 1);
-lean_inc(x_315);
-x_316 = lean_ctor_get(x_184, 2);
-lean_inc(x_316);
-x_317 = lean_ctor_get(x_184, 3);
-lean_inc(x_317);
-if (lean_is_exclusive(x_184)) {
- lean_ctor_release(x_184, 0);
- lean_ctor_release(x_184, 1);
- lean_ctor_release(x_184, 2);
- lean_ctor_release(x_184, 3);
- x_318 = x_184;
-} else {
- lean_dec_ref(x_184);
- x_318 = lean_box(0);
-}
-if (lean_is_scalar(x_318)) {
- x_319 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_319 = x_318;
-}
-lean_ctor_set(x_319, 0, x_314);
-lean_ctor_set(x_319, 1, x_315);
-lean_ctor_set(x_319, 2, x_316);
-lean_ctor_set(x_319, 3, x_317);
-lean_ctor_set_uint8(x_319, sizeof(void*)*4, x_266);
-x_320 = 0;
-x_321 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_321, 0, x_319);
-lean_ctor_set(x_321, 1, x_312);
-lean_ctor_set(x_321, 2, x_313);
-lean_ctor_set(x_321, 3, x_257);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_320);
-lean_ctor_set(x_2, 0, x_321);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_266);
-return x_2;
-}
-}
-}
-}
-}
-}
-}
-}
-else
-{
-lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; uint8_t x_327; 
-x_322 = lean_ctor_get(x_2, 0);
-x_323 = lean_ctor_get(x_2, 1);
-x_324 = lean_ctor_get(x_2, 2);
-x_325 = lean_ctor_get(x_2, 3);
-lean_inc(x_325);
-lean_inc(x_324);
-lean_inc(x_323);
-lean_inc(x_322);
-lean_dec(x_2);
-lean_inc(x_1);
-lean_inc(x_323);
-lean_inc(x_3);
-x_326 = lean_apply_2(x_1, x_3, x_323);
-x_327 = lean_unbox(x_326);
-lean_dec(x_326);
-if (x_327 == 0)
-{
-lean_object* x_328; uint8_t x_329; 
-lean_inc(x_1);
-lean_inc(x_3);
-lean_inc(x_323);
-x_328 = lean_apply_2(x_1, x_323, x_3);
-x_329 = lean_unbox(x_328);
-lean_dec(x_328);
-if (x_329 == 0)
-{
-lean_object* x_330; 
-lean_dec(x_324);
-lean_dec(x_323);
-lean_dec(x_1);
-x_330 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_330, 0, x_322);
-lean_ctor_set(x_330, 1, x_3);
-lean_ctor_set(x_330, 2, x_4);
-lean_ctor_set(x_330, 3, x_325);
-lean_ctor_set_uint8(x_330, sizeof(void*)*4, x_7);
-return x_330;
-}
-else
-{
-uint8_t x_331; 
-x_331 = l_Std_RBNode_isRed___rarg(x_325);
-if (x_331 == 0)
-{
-lean_object* x_332; lean_object* x_333; 
-x_332 = l_Std_RBNode_ins___main___rarg(x_1, x_325, x_3, x_4);
-x_333 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_333, 0, x_322);
-lean_ctor_set(x_333, 1, x_323);
-lean_ctor_set(x_333, 2, x_324);
-lean_ctor_set(x_333, 3, x_332);
-lean_ctor_set_uint8(x_333, sizeof(void*)*4, x_7);
-return x_333;
-}
-else
-{
-lean_object* x_334; lean_object* x_335; 
-x_334 = l_Std_RBNode_ins___main___rarg(x_1, x_325, x_3, x_4);
-x_335 = lean_ctor_get(x_334, 0);
-lean_inc(x_335);
-if (lean_obj_tag(x_335) == 0)
-{
-lean_object* x_336; 
-x_336 = lean_ctor_get(x_334, 3);
-lean_inc(x_336);
-if (lean_obj_tag(x_336) == 0)
-{
-lean_object* x_337; lean_object* x_338; lean_object* x_339; uint8_t x_340; lean_object* x_341; uint8_t x_342; lean_object* x_343; 
-x_337 = lean_ctor_get(x_334, 1);
-lean_inc(x_337);
-x_338 = lean_ctor_get(x_334, 2);
-lean_inc(x_338);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- lean_ctor_release(x_334, 2);
- lean_ctor_release(x_334, 3);
- x_339 = x_334;
-} else {
- lean_dec_ref(x_334);
- x_339 = lean_box(0);
-}
-x_340 = 0;
-if (lean_is_scalar(x_339)) {
- x_341 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_341 = x_339;
-}
-lean_ctor_set(x_341, 0, x_336);
-lean_ctor_set(x_341, 1, x_337);
-lean_ctor_set(x_341, 2, x_338);
-lean_ctor_set(x_341, 3, x_336);
-lean_ctor_set_uint8(x_341, sizeof(void*)*4, x_340);
-x_342 = 1;
-x_343 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_343, 0, x_322);
-lean_ctor_set(x_343, 1, x_323);
-lean_ctor_set(x_343, 2, x_324);
-lean_ctor_set(x_343, 3, x_341);
-lean_ctor_set_uint8(x_343, sizeof(void*)*4, x_342);
-return x_343;
-}
-else
-{
-uint8_t x_344; 
-x_344 = lean_ctor_get_uint8(x_336, sizeof(void*)*4);
-if (x_344 == 0)
-{
-lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; uint8_t x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; 
-x_345 = lean_ctor_get(x_334, 1);
-lean_inc(x_345);
-x_346 = lean_ctor_get(x_334, 2);
-lean_inc(x_346);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- lean_ctor_release(x_334, 2);
- lean_ctor_release(x_334, 3);
- x_347 = x_334;
-} else {
- lean_dec_ref(x_334);
- x_347 = lean_box(0);
-}
-x_348 = lean_ctor_get(x_336, 0);
-lean_inc(x_348);
-x_349 = lean_ctor_get(x_336, 1);
-lean_inc(x_349);
-x_350 = lean_ctor_get(x_336, 2);
-lean_inc(x_350);
-x_351 = lean_ctor_get(x_336, 3);
-lean_inc(x_351);
-if (lean_is_exclusive(x_336)) {
- lean_ctor_release(x_336, 0);
- lean_ctor_release(x_336, 1);
- lean_ctor_release(x_336, 2);
- lean_ctor_release(x_336, 3);
- x_352 = x_336;
-} else {
- lean_dec_ref(x_336);
- x_352 = lean_box(0);
-}
-x_353 = 1;
-if (lean_is_scalar(x_352)) {
- x_354 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_354 = x_352;
-}
-lean_ctor_set(x_354, 0, x_322);
-lean_ctor_set(x_354, 1, x_323);
-lean_ctor_set(x_354, 2, x_324);
-lean_ctor_set(x_354, 3, x_335);
-lean_ctor_set_uint8(x_354, sizeof(void*)*4, x_353);
-if (lean_is_scalar(x_347)) {
- x_355 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_355 = x_347;
-}
-lean_ctor_set(x_355, 0, x_348);
-lean_ctor_set(x_355, 1, x_349);
-lean_ctor_set(x_355, 2, x_350);
-lean_ctor_set(x_355, 3, x_351);
-lean_ctor_set_uint8(x_355, sizeof(void*)*4, x_353);
-x_356 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_356, 0, x_354);
-lean_ctor_set(x_356, 1, x_345);
-lean_ctor_set(x_356, 2, x_346);
-lean_ctor_set(x_356, 3, x_355);
-lean_ctor_set_uint8(x_356, sizeof(void*)*4, x_344);
-return x_356;
-}
-else
-{
-lean_object* x_357; lean_object* x_358; lean_object* x_359; uint8_t x_360; lean_object* x_361; lean_object* x_362; 
-x_357 = lean_ctor_get(x_334, 1);
-lean_inc(x_357);
-x_358 = lean_ctor_get(x_334, 2);
-lean_inc(x_358);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- lean_ctor_release(x_334, 2);
- lean_ctor_release(x_334, 3);
- x_359 = x_334;
-} else {
- lean_dec_ref(x_334);
- x_359 = lean_box(0);
-}
-x_360 = 0;
-if (lean_is_scalar(x_359)) {
- x_361 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_361 = x_359;
-}
-lean_ctor_set(x_361, 0, x_335);
-lean_ctor_set(x_361, 1, x_357);
-lean_ctor_set(x_361, 2, x_358);
-lean_ctor_set(x_361, 3, x_336);
-lean_ctor_set_uint8(x_361, sizeof(void*)*4, x_360);
-x_362 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_362, 0, x_322);
-lean_ctor_set(x_362, 1, x_323);
-lean_ctor_set(x_362, 2, x_324);
-lean_ctor_set(x_362, 3, x_361);
-lean_ctor_set_uint8(x_362, sizeof(void*)*4, x_344);
-return x_362;
-}
-}
-}
-else
-{
-uint8_t x_363; 
-x_363 = lean_ctor_get_uint8(x_335, sizeof(void*)*4);
-if (x_363 == 0)
-{
-lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; lean_object* x_370; lean_object* x_371; lean_object* x_372; uint8_t x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; 
-x_364 = lean_ctor_get(x_334, 1);
-lean_inc(x_364);
-x_365 = lean_ctor_get(x_334, 2);
-lean_inc(x_365);
-x_366 = lean_ctor_get(x_334, 3);
-lean_inc(x_366);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- lean_ctor_release(x_334, 2);
- lean_ctor_release(x_334, 3);
- x_367 = x_334;
-} else {
- lean_dec_ref(x_334);
- x_367 = lean_box(0);
-}
-x_368 = lean_ctor_get(x_335, 0);
-lean_inc(x_368);
-x_369 = lean_ctor_get(x_335, 1);
-lean_inc(x_369);
-x_370 = lean_ctor_get(x_335, 2);
-lean_inc(x_370);
-x_371 = lean_ctor_get(x_335, 3);
-lean_inc(x_371);
-if (lean_is_exclusive(x_335)) {
- lean_ctor_release(x_335, 0);
- lean_ctor_release(x_335, 1);
- lean_ctor_release(x_335, 2);
- lean_ctor_release(x_335, 3);
- x_372 = x_335;
-} else {
- lean_dec_ref(x_335);
- x_372 = lean_box(0);
-}
-x_373 = 1;
-if (lean_is_scalar(x_372)) {
- x_374 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_374 = x_372;
-}
-lean_ctor_set(x_374, 0, x_322);
-lean_ctor_set(x_374, 1, x_323);
-lean_ctor_set(x_374, 2, x_324);
-lean_ctor_set(x_374, 3, x_368);
-lean_ctor_set_uint8(x_374, sizeof(void*)*4, x_373);
-if (lean_is_scalar(x_367)) {
- x_375 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_375 = x_367;
-}
-lean_ctor_set(x_375, 0, x_371);
-lean_ctor_set(x_375, 1, x_364);
-lean_ctor_set(x_375, 2, x_365);
-lean_ctor_set(x_375, 3, x_366);
-lean_ctor_set_uint8(x_375, sizeof(void*)*4, x_373);
-x_376 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_376, 0, x_374);
-lean_ctor_set(x_376, 1, x_369);
-lean_ctor_set(x_376, 2, x_370);
-lean_ctor_set(x_376, 3, x_375);
-lean_ctor_set_uint8(x_376, sizeof(void*)*4, x_363);
-return x_376;
-}
-else
-{
-lean_object* x_377; 
-x_377 = lean_ctor_get(x_334, 3);
-lean_inc(x_377);
-if (lean_obj_tag(x_377) == 0)
-{
-lean_object* x_378; lean_object* x_379; lean_object* x_380; uint8_t x_381; lean_object* x_382; lean_object* x_383; 
-x_378 = lean_ctor_get(x_334, 1);
-lean_inc(x_378);
-x_379 = lean_ctor_get(x_334, 2);
-lean_inc(x_379);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- lean_ctor_release(x_334, 2);
- lean_ctor_release(x_334, 3);
- x_380 = x_334;
-} else {
- lean_dec_ref(x_334);
- x_380 = lean_box(0);
-}
-x_381 = 0;
-if (lean_is_scalar(x_380)) {
- x_382 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_382 = x_380;
-}
-lean_ctor_set(x_382, 0, x_335);
-lean_ctor_set(x_382, 1, x_378);
-lean_ctor_set(x_382, 2, x_379);
-lean_ctor_set(x_382, 3, x_377);
-lean_ctor_set_uint8(x_382, sizeof(void*)*4, x_381);
-x_383 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_383, 0, x_322);
-lean_ctor_set(x_383, 1, x_323);
-lean_ctor_set(x_383, 2, x_324);
-lean_ctor_set(x_383, 3, x_382);
-lean_ctor_set_uint8(x_383, sizeof(void*)*4, x_363);
-return x_383;
-}
-else
-{
-uint8_t x_384; 
-x_384 = lean_ctor_get_uint8(x_377, sizeof(void*)*4);
-if (x_384 == 0)
-{
-lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; lean_object* x_396; 
-x_385 = lean_ctor_get(x_334, 1);
-lean_inc(x_385);
-x_386 = lean_ctor_get(x_334, 2);
-lean_inc(x_386);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- lean_ctor_release(x_334, 2);
- lean_ctor_release(x_334, 3);
- x_387 = x_334;
-} else {
- lean_dec_ref(x_334);
- x_387 = lean_box(0);
-}
-x_388 = lean_ctor_get(x_377, 0);
-lean_inc(x_388);
-x_389 = lean_ctor_get(x_377, 1);
-lean_inc(x_389);
-x_390 = lean_ctor_get(x_377, 2);
-lean_inc(x_390);
-x_391 = lean_ctor_get(x_377, 3);
-lean_inc(x_391);
-if (lean_is_exclusive(x_377)) {
- lean_ctor_release(x_377, 0);
- lean_ctor_release(x_377, 1);
- lean_ctor_release(x_377, 2);
- lean_ctor_release(x_377, 3);
- x_392 = x_377;
-} else {
- lean_dec_ref(x_377);
- x_392 = lean_box(0);
-}
-lean_inc(x_335);
-if (lean_is_scalar(x_392)) {
- x_393 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_393 = x_392;
-}
-lean_ctor_set(x_393, 0, x_322);
-lean_ctor_set(x_393, 1, x_323);
-lean_ctor_set(x_393, 2, x_324);
-lean_ctor_set(x_393, 3, x_335);
-if (lean_is_exclusive(x_335)) {
- lean_ctor_release(x_335, 0);
- lean_ctor_release(x_335, 1);
- lean_ctor_release(x_335, 2);
- lean_ctor_release(x_335, 3);
- x_394 = x_335;
-} else {
- lean_dec_ref(x_335);
- x_394 = lean_box(0);
-}
-lean_ctor_set_uint8(x_393, sizeof(void*)*4, x_363);
-if (lean_is_scalar(x_394)) {
- x_395 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_395 = x_394;
-}
-lean_ctor_set(x_395, 0, x_388);
-lean_ctor_set(x_395, 1, x_389);
-lean_ctor_set(x_395, 2, x_390);
-lean_ctor_set(x_395, 3, x_391);
-lean_ctor_set_uint8(x_395, sizeof(void*)*4, x_363);
-if (lean_is_scalar(x_387)) {
- x_396 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_396 = x_387;
-}
-lean_ctor_set(x_396, 0, x_393);
-lean_ctor_set(x_396, 1, x_385);
-lean_ctor_set(x_396, 2, x_386);
-lean_ctor_set(x_396, 3, x_395);
-lean_ctor_set_uint8(x_396, sizeof(void*)*4, x_384);
-return x_396;
-}
-else
-{
-lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; lean_object* x_408; 
-x_397 = lean_ctor_get(x_334, 1);
-lean_inc(x_397);
-x_398 = lean_ctor_get(x_334, 2);
-lean_inc(x_398);
-if (lean_is_exclusive(x_334)) {
- lean_ctor_release(x_334, 0);
- lean_ctor_release(x_334, 1);
- lean_ctor_release(x_334, 2);
- lean_ctor_release(x_334, 3);
- x_399 = x_334;
-} else {
- lean_dec_ref(x_334);
- x_399 = lean_box(0);
-}
-x_400 = lean_ctor_get(x_335, 0);
-lean_inc(x_400);
-x_401 = lean_ctor_get(x_335, 1);
-lean_inc(x_401);
-x_402 = lean_ctor_get(x_335, 2);
-lean_inc(x_402);
-x_403 = lean_ctor_get(x_335, 3);
-lean_inc(x_403);
-if (lean_is_exclusive(x_335)) {
- lean_ctor_release(x_335, 0);
- lean_ctor_release(x_335, 1);
- lean_ctor_release(x_335, 2);
- lean_ctor_release(x_335, 3);
- x_404 = x_335;
-} else {
- lean_dec_ref(x_335);
- x_404 = lean_box(0);
-}
-if (lean_is_scalar(x_404)) {
- x_405 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_405 = x_404;
-}
-lean_ctor_set(x_405, 0, x_400);
-lean_ctor_set(x_405, 1, x_401);
-lean_ctor_set(x_405, 2, x_402);
-lean_ctor_set(x_405, 3, x_403);
-lean_ctor_set_uint8(x_405, sizeof(void*)*4, x_384);
-x_406 = 0;
-if (lean_is_scalar(x_399)) {
- x_407 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_407 = x_399;
-}
-lean_ctor_set(x_407, 0, x_405);
-lean_ctor_set(x_407, 1, x_397);
-lean_ctor_set(x_407, 2, x_398);
-lean_ctor_set(x_407, 3, x_377);
-lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
-x_408 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_408, 0, x_322);
-lean_ctor_set(x_408, 1, x_323);
-lean_ctor_set(x_408, 2, x_324);
-lean_ctor_set(x_408, 3, x_407);
-lean_ctor_set_uint8(x_408, sizeof(void*)*4, x_384);
-return x_408;
-}
-}
-}
-}
-}
-}
-}
-else
-{
-uint8_t x_409; 
-x_409 = l_Std_RBNode_isRed___rarg(x_322);
-if (x_409 == 0)
-{
-lean_object* x_410; lean_object* x_411; 
-x_410 = l_Std_RBNode_ins___main___rarg(x_1, x_322, x_3, x_4);
-x_411 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_411, 0, x_410);
-lean_ctor_set(x_411, 1, x_323);
-lean_ctor_set(x_411, 2, x_324);
-lean_ctor_set(x_411, 3, x_325);
-lean_ctor_set_uint8(x_411, sizeof(void*)*4, x_7);
-return x_411;
-}
-else
-{
-lean_object* x_412; lean_object* x_413; 
-x_412 = l_Std_RBNode_ins___main___rarg(x_1, x_322, x_3, x_4);
-x_413 = lean_ctor_get(x_412, 0);
-lean_inc(x_413);
-if (lean_obj_tag(x_413) == 0)
-{
-lean_object* x_414; 
-x_414 = lean_ctor_get(x_412, 3);
-lean_inc(x_414);
-if (lean_obj_tag(x_414) == 0)
-{
-lean_object* x_415; lean_object* x_416; lean_object* x_417; uint8_t x_418; lean_object* x_419; uint8_t x_420; lean_object* x_421; 
-x_415 = lean_ctor_get(x_412, 1);
-lean_inc(x_415);
-x_416 = lean_ctor_get(x_412, 2);
-lean_inc(x_416);
-if (lean_is_exclusive(x_412)) {
- lean_ctor_release(x_412, 0);
- lean_ctor_release(x_412, 1);
- lean_ctor_release(x_412, 2);
- lean_ctor_release(x_412, 3);
- x_417 = x_412;
-} else {
- lean_dec_ref(x_412);
- x_417 = lean_box(0);
-}
-x_418 = 0;
-if (lean_is_scalar(x_417)) {
- x_419 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_419 = x_417;
-}
-lean_ctor_set(x_419, 0, x_414);
-lean_ctor_set(x_419, 1, x_415);
-lean_ctor_set(x_419, 2, x_416);
-lean_ctor_set(x_419, 3, x_414);
-lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_418);
-x_420 = 1;
-x_421 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_421, 0, x_419);
-lean_ctor_set(x_421, 1, x_323);
-lean_ctor_set(x_421, 2, x_324);
-lean_ctor_set(x_421, 3, x_325);
-lean_ctor_set_uint8(x_421, sizeof(void*)*4, x_420);
-return x_421;
-}
-else
-{
-uint8_t x_422; 
-x_422 = lean_ctor_get_uint8(x_414, sizeof(void*)*4);
-if (x_422 == 0)
-{
-lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; uint8_t x_431; lean_object* x_432; lean_object* x_433; lean_object* x_434; 
-x_423 = lean_ctor_get(x_412, 1);
-lean_inc(x_423);
-x_424 = lean_ctor_get(x_412, 2);
-lean_inc(x_424);
-if (lean_is_exclusive(x_412)) {
- lean_ctor_release(x_412, 0);
- lean_ctor_release(x_412, 1);
- lean_ctor_release(x_412, 2);
- lean_ctor_release(x_412, 3);
- x_425 = x_412;
-} else {
- lean_dec_ref(x_412);
- x_425 = lean_box(0);
-}
-x_426 = lean_ctor_get(x_414, 0);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_414, 1);
-lean_inc(x_427);
-x_428 = lean_ctor_get(x_414, 2);
-lean_inc(x_428);
-x_429 = lean_ctor_get(x_414, 3);
-lean_inc(x_429);
-if (lean_is_exclusive(x_414)) {
- lean_ctor_release(x_414, 0);
- lean_ctor_release(x_414, 1);
- lean_ctor_release(x_414, 2);
- lean_ctor_release(x_414, 3);
- x_430 = x_414;
-} else {
- lean_dec_ref(x_414);
- x_430 = lean_box(0);
-}
-x_431 = 1;
-if (lean_is_scalar(x_430)) {
- x_432 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_432 = x_430;
-}
-lean_ctor_set(x_432, 0, x_413);
-lean_ctor_set(x_432, 1, x_423);
-lean_ctor_set(x_432, 2, x_424);
-lean_ctor_set(x_432, 3, x_426);
-lean_ctor_set_uint8(x_432, sizeof(void*)*4, x_431);
-if (lean_is_scalar(x_425)) {
- x_433 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_433 = x_425;
-}
-lean_ctor_set(x_433, 0, x_429);
-lean_ctor_set(x_433, 1, x_323);
-lean_ctor_set(x_433, 2, x_324);
-lean_ctor_set(x_433, 3, x_325);
-lean_ctor_set_uint8(x_433, sizeof(void*)*4, x_431);
-x_434 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_434, 0, x_432);
-lean_ctor_set(x_434, 1, x_427);
-lean_ctor_set(x_434, 2, x_428);
-lean_ctor_set(x_434, 3, x_433);
-lean_ctor_set_uint8(x_434, sizeof(void*)*4, x_422);
-return x_434;
-}
-else
-{
-lean_object* x_435; lean_object* x_436; lean_object* x_437; uint8_t x_438; lean_object* x_439; lean_object* x_440; 
-x_435 = lean_ctor_get(x_412, 1);
-lean_inc(x_435);
-x_436 = lean_ctor_get(x_412, 2);
-lean_inc(x_436);
-if (lean_is_exclusive(x_412)) {
- lean_ctor_release(x_412, 0);
- lean_ctor_release(x_412, 1);
- lean_ctor_release(x_412, 2);
- lean_ctor_release(x_412, 3);
- x_437 = x_412;
-} else {
- lean_dec_ref(x_412);
- x_437 = lean_box(0);
-}
-x_438 = 0;
-if (lean_is_scalar(x_437)) {
- x_439 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_439 = x_437;
-}
-lean_ctor_set(x_439, 0, x_413);
-lean_ctor_set(x_439, 1, x_435);
-lean_ctor_set(x_439, 2, x_436);
-lean_ctor_set(x_439, 3, x_414);
-lean_ctor_set_uint8(x_439, sizeof(void*)*4, x_438);
-x_440 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_440, 0, x_439);
-lean_ctor_set(x_440, 1, x_323);
-lean_ctor_set(x_440, 2, x_324);
-lean_ctor_set(x_440, 3, x_325);
-lean_ctor_set_uint8(x_440, sizeof(void*)*4, x_422);
-return x_440;
-}
-}
-}
-else
-{
-uint8_t x_441; 
-x_441 = lean_ctor_get_uint8(x_413, sizeof(void*)*4);
-if (x_441 == 0)
-{
-lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; uint8_t x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; 
-x_442 = lean_ctor_get(x_412, 1);
-lean_inc(x_442);
-x_443 = lean_ctor_get(x_412, 2);
-lean_inc(x_443);
-x_444 = lean_ctor_get(x_412, 3);
-lean_inc(x_444);
-if (lean_is_exclusive(x_412)) {
- lean_ctor_release(x_412, 0);
- lean_ctor_release(x_412, 1);
- lean_ctor_release(x_412, 2);
- lean_ctor_release(x_412, 3);
- x_445 = x_412;
-} else {
- lean_dec_ref(x_412);
- x_445 = lean_box(0);
-}
-x_446 = lean_ctor_get(x_413, 0);
-lean_inc(x_446);
-x_447 = lean_ctor_get(x_413, 1);
-lean_inc(x_447);
-x_448 = lean_ctor_get(x_413, 2);
-lean_inc(x_448);
-x_449 = lean_ctor_get(x_413, 3);
-lean_inc(x_449);
-if (lean_is_exclusive(x_413)) {
- lean_ctor_release(x_413, 0);
- lean_ctor_release(x_413, 1);
- lean_ctor_release(x_413, 2);
- lean_ctor_release(x_413, 3);
- x_450 = x_413;
-} else {
- lean_dec_ref(x_413);
- x_450 = lean_box(0);
-}
-x_451 = 1;
-if (lean_is_scalar(x_450)) {
- x_452 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_452 = x_450;
-}
-lean_ctor_set(x_452, 0, x_446);
-lean_ctor_set(x_452, 1, x_447);
-lean_ctor_set(x_452, 2, x_448);
-lean_ctor_set(x_452, 3, x_449);
-lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_451);
-if (lean_is_scalar(x_445)) {
- x_453 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_453 = x_445;
-}
-lean_ctor_set(x_453, 0, x_444);
-lean_ctor_set(x_453, 1, x_323);
-lean_ctor_set(x_453, 2, x_324);
-lean_ctor_set(x_453, 3, x_325);
-lean_ctor_set_uint8(x_453, sizeof(void*)*4, x_451);
-x_454 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_454, 0, x_452);
-lean_ctor_set(x_454, 1, x_442);
-lean_ctor_set(x_454, 2, x_443);
-lean_ctor_set(x_454, 3, x_453);
-lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_441);
-return x_454;
-}
-else
-{
-lean_object* x_455; 
-x_455 = lean_ctor_get(x_412, 3);
-lean_inc(x_455);
-if (lean_obj_tag(x_455) == 0)
-{
-lean_object* x_456; lean_object* x_457; lean_object* x_458; uint8_t x_459; lean_object* x_460; lean_object* x_461; 
-x_456 = lean_ctor_get(x_412, 1);
-lean_inc(x_456);
-x_457 = lean_ctor_get(x_412, 2);
-lean_inc(x_457);
-if (lean_is_exclusive(x_412)) {
- lean_ctor_release(x_412, 0);
- lean_ctor_release(x_412, 1);
- lean_ctor_release(x_412, 2);
- lean_ctor_release(x_412, 3);
- x_458 = x_412;
-} else {
- lean_dec_ref(x_412);
- x_458 = lean_box(0);
-}
-x_459 = 0;
-if (lean_is_scalar(x_458)) {
- x_460 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_460 = x_458;
-}
-lean_ctor_set(x_460, 0, x_413);
-lean_ctor_set(x_460, 1, x_456);
-lean_ctor_set(x_460, 2, x_457);
-lean_ctor_set(x_460, 3, x_455);
-lean_ctor_set_uint8(x_460, sizeof(void*)*4, x_459);
-x_461 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_461, 0, x_460);
-lean_ctor_set(x_461, 1, x_323);
-lean_ctor_set(x_461, 2, x_324);
-lean_ctor_set(x_461, 3, x_325);
-lean_ctor_set_uint8(x_461, sizeof(void*)*4, x_441);
-return x_461;
-}
-else
-{
-uint8_t x_462; 
-x_462 = lean_ctor_get_uint8(x_455, sizeof(void*)*4);
-if (x_462 == 0)
-{
-lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; 
-x_463 = lean_ctor_get(x_412, 1);
-lean_inc(x_463);
-x_464 = lean_ctor_get(x_412, 2);
-lean_inc(x_464);
-if (lean_is_exclusive(x_412)) {
- lean_ctor_release(x_412, 0);
- lean_ctor_release(x_412, 1);
- lean_ctor_release(x_412, 2);
- lean_ctor_release(x_412, 3);
- x_465 = x_412;
-} else {
- lean_dec_ref(x_412);
- x_465 = lean_box(0);
-}
-x_466 = lean_ctor_get(x_455, 0);
-lean_inc(x_466);
-x_467 = lean_ctor_get(x_455, 1);
-lean_inc(x_467);
-x_468 = lean_ctor_get(x_455, 2);
-lean_inc(x_468);
-x_469 = lean_ctor_get(x_455, 3);
-lean_inc(x_469);
-if (lean_is_exclusive(x_455)) {
- lean_ctor_release(x_455, 0);
- lean_ctor_release(x_455, 1);
- lean_ctor_release(x_455, 2);
- lean_ctor_release(x_455, 3);
- x_470 = x_455;
-} else {
- lean_dec_ref(x_455);
- x_470 = lean_box(0);
-}
-lean_inc(x_413);
-if (lean_is_scalar(x_470)) {
- x_471 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_471 = x_470;
-}
-lean_ctor_set(x_471, 0, x_413);
-lean_ctor_set(x_471, 1, x_463);
-lean_ctor_set(x_471, 2, x_464);
-lean_ctor_set(x_471, 3, x_466);
-if (lean_is_exclusive(x_413)) {
- lean_ctor_release(x_413, 0);
- lean_ctor_release(x_413, 1);
- lean_ctor_release(x_413, 2);
- lean_ctor_release(x_413, 3);
- x_472 = x_413;
-} else {
- lean_dec_ref(x_413);
- x_472 = lean_box(0);
-}
-lean_ctor_set_uint8(x_471, sizeof(void*)*4, x_441);
-if (lean_is_scalar(x_472)) {
- x_473 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_473 = x_472;
-}
-lean_ctor_set(x_473, 0, x_469);
-lean_ctor_set(x_473, 1, x_323);
-lean_ctor_set(x_473, 2, x_324);
-lean_ctor_set(x_473, 3, x_325);
-lean_ctor_set_uint8(x_473, sizeof(void*)*4, x_441);
-if (lean_is_scalar(x_465)) {
- x_474 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_474 = x_465;
-}
-lean_ctor_set(x_474, 0, x_471);
-lean_ctor_set(x_474, 1, x_467);
-lean_ctor_set(x_474, 2, x_468);
-lean_ctor_set(x_474, 3, x_473);
-lean_ctor_set_uint8(x_474, sizeof(void*)*4, x_462);
-return x_474;
-}
-else
-{
-lean_object* x_475; lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; uint8_t x_484; lean_object* x_485; lean_object* x_486; 
-x_475 = lean_ctor_get(x_412, 1);
-lean_inc(x_475);
-x_476 = lean_ctor_get(x_412, 2);
-lean_inc(x_476);
-if (lean_is_exclusive(x_412)) {
- lean_ctor_release(x_412, 0);
- lean_ctor_release(x_412, 1);
- lean_ctor_release(x_412, 2);
- lean_ctor_release(x_412, 3);
- x_477 = x_412;
-} else {
- lean_dec_ref(x_412);
- x_477 = lean_box(0);
-}
-x_478 = lean_ctor_get(x_413, 0);
-lean_inc(x_478);
-x_479 = lean_ctor_get(x_413, 1);
-lean_inc(x_479);
-x_480 = lean_ctor_get(x_413, 2);
-lean_inc(x_480);
-x_481 = lean_ctor_get(x_413, 3);
-lean_inc(x_481);
-if (lean_is_exclusive(x_413)) {
- lean_ctor_release(x_413, 0);
- lean_ctor_release(x_413, 1);
- lean_ctor_release(x_413, 2);
- lean_ctor_release(x_413, 3);
- x_482 = x_413;
-} else {
- lean_dec_ref(x_413);
- x_482 = lean_box(0);
-}
-if (lean_is_scalar(x_482)) {
- x_483 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_483 = x_482;
-}
-lean_ctor_set(x_483, 0, x_478);
-lean_ctor_set(x_483, 1, x_479);
-lean_ctor_set(x_483, 2, x_480);
-lean_ctor_set(x_483, 3, x_481);
-lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_462);
-x_484 = 0;
-if (lean_is_scalar(x_477)) {
- x_485 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_485 = x_477;
-}
-lean_ctor_set(x_485, 0, x_483);
-lean_ctor_set(x_485, 1, x_475);
-lean_ctor_set(x_485, 2, x_476);
-lean_ctor_set(x_485, 3, x_455);
-lean_ctor_set_uint8(x_485, sizeof(void*)*4, x_484);
-x_486 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_486, 0, x_485);
-lean_ctor_set(x_486, 1, x_323);
-lean_ctor_set(x_486, 2, x_324);
-lean_ctor_set(x_486, 3, x_325);
-lean_ctor_set_uint8(x_486, sizeof(void*)*4, x_462);
-return x_486;
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-}
-lean_object* l_Std_RBNode_ins___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_ins_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_ins___main___rarg), 4, 0);
-return x_3;
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_ins_match__1___rarg), 6, 0);
+return x_4;
 }
 }
 lean_object* l_Std_RBNode_ins___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
-lean_object* x_5; 
-x_5 = l_Std_RBNode_ins___main___rarg(x_1, x_2, x_3, x_4);
-return x_5;
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_5; uint8_t x_6; lean_object* x_7; 
+lean_dec(x_1);
+x_5 = lean_box(0);
+x_6 = 0;
+x_7 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_7, 0, x_5);
+lean_ctor_set(x_7, 1, x_3);
+lean_ctor_set(x_7, 2, x_4);
+lean_ctor_set(x_7, 3, x_5);
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_6);
+return x_7;
+}
+else
+{
+uint8_t x_8; 
+x_8 = lean_ctor_get_uint8(x_2, sizeof(void*)*4);
+if (x_8 == 0)
+{
+uint8_t x_9; 
+x_9 = !lean_is_exclusive(x_2);
+if (x_9 == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; 
+x_10 = lean_ctor_get(x_2, 0);
+x_11 = lean_ctor_get(x_2, 1);
+x_12 = lean_ctor_get(x_2, 2);
+x_13 = lean_ctor_get(x_2, 3);
+lean_inc(x_1);
+lean_inc(x_11);
+lean_inc(x_3);
+x_14 = lean_apply_2(x_1, x_3, x_11);
+x_15 = lean_unbox(x_14);
+lean_dec(x_14);
+if (x_15 == 0)
+{
+lean_object* x_16; uint8_t x_17; 
+lean_inc(x_1);
+lean_inc(x_3);
+lean_inc(x_11);
+x_16 = lean_apply_2(x_1, x_11, x_3);
+x_17 = lean_unbox(x_16);
+lean_dec(x_16);
+if (x_17 == 0)
+{
+uint8_t x_18; 
+lean_dec(x_12);
+lean_dec(x_11);
+lean_dec(x_1);
+x_18 = 0;
+lean_ctor_set(x_2, 2, x_4);
+lean_ctor_set(x_2, 1, x_3);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_18);
+return x_2;
+}
+else
+{
+lean_object* x_19; uint8_t x_20; 
+x_19 = l_Std_RBNode_ins___rarg(x_1, x_13, x_3, x_4);
+x_20 = 0;
+lean_ctor_set(x_2, 3, x_19);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_20);
+return x_2;
+}
+}
+else
+{
+lean_object* x_21; uint8_t x_22; 
+x_21 = l_Std_RBNode_ins___rarg(x_1, x_10, x_3, x_4);
+x_22 = 0;
+lean_ctor_set(x_2, 0, x_21);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_22);
+return x_2;
+}
+}
+else
+{
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; 
+x_23 = lean_ctor_get(x_2, 0);
+x_24 = lean_ctor_get(x_2, 1);
+x_25 = lean_ctor_get(x_2, 2);
+x_26 = lean_ctor_get(x_2, 3);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_inc(x_24);
+lean_inc(x_23);
+lean_dec(x_2);
+lean_inc(x_1);
+lean_inc(x_24);
+lean_inc(x_3);
+x_27 = lean_apply_2(x_1, x_3, x_24);
+x_28 = lean_unbox(x_27);
+lean_dec(x_27);
+if (x_28 == 0)
+{
+lean_object* x_29; uint8_t x_30; 
+lean_inc(x_1);
+lean_inc(x_3);
+lean_inc(x_24);
+x_29 = lean_apply_2(x_1, x_24, x_3);
+x_30 = lean_unbox(x_29);
+lean_dec(x_29);
+if (x_30 == 0)
+{
+uint8_t x_31; lean_object* x_32; 
+lean_dec(x_25);
+lean_dec(x_24);
+lean_dec(x_1);
+x_31 = 0;
+x_32 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_32, 0, x_23);
+lean_ctor_set(x_32, 1, x_3);
+lean_ctor_set(x_32, 2, x_4);
+lean_ctor_set(x_32, 3, x_26);
+lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31);
+return x_32;
+}
+else
+{
+lean_object* x_33; uint8_t x_34; lean_object* x_35; 
+x_33 = l_Std_RBNode_ins___rarg(x_1, x_26, x_3, x_4);
+x_34 = 0;
+x_35 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_35, 0, x_23);
+lean_ctor_set(x_35, 1, x_24);
+lean_ctor_set(x_35, 2, x_25);
+lean_ctor_set(x_35, 3, x_33);
+lean_ctor_set_uint8(x_35, sizeof(void*)*4, x_34);
+return x_35;
+}
+}
+else
+{
+lean_object* x_36; uint8_t x_37; lean_object* x_38; 
+x_36 = l_Std_RBNode_ins___rarg(x_1, x_23, x_3, x_4);
+x_37 = 0;
+x_38 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_24);
+lean_ctor_set(x_38, 2, x_25);
+lean_ctor_set(x_38, 3, x_26);
+lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_37);
+return x_38;
+}
+}
+}
+else
+{
+uint8_t x_39; 
+x_39 = !lean_is_exclusive(x_2);
+if (x_39 == 0)
+{
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; 
+x_40 = lean_ctor_get(x_2, 0);
+x_41 = lean_ctor_get(x_2, 1);
+x_42 = lean_ctor_get(x_2, 2);
+x_43 = lean_ctor_get(x_2, 3);
+lean_inc(x_1);
+lean_inc(x_41);
+lean_inc(x_3);
+x_44 = lean_apply_2(x_1, x_3, x_41);
+x_45 = lean_unbox(x_44);
+lean_dec(x_44);
+if (x_45 == 0)
+{
+lean_object* x_46; uint8_t x_47; 
+lean_inc(x_1);
+lean_inc(x_3);
+lean_inc(x_41);
+x_46 = lean_apply_2(x_1, x_41, x_3);
+x_47 = lean_unbox(x_46);
+lean_dec(x_46);
+if (x_47 == 0)
+{
+uint8_t x_48; 
+lean_dec(x_42);
+lean_dec(x_41);
+lean_dec(x_1);
+x_48 = 1;
+lean_ctor_set(x_2, 2, x_4);
+lean_ctor_set(x_2, 1, x_3);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_48);
+return x_2;
+}
+else
+{
+uint8_t x_49; 
+x_49 = l_Std_RBNode_isRed___rarg(x_43);
+if (x_49 == 0)
+{
+lean_object* x_50; uint8_t x_51; 
+x_50 = l_Std_RBNode_ins___rarg(x_1, x_43, x_3, x_4);
+x_51 = 1;
+lean_ctor_set(x_2, 3, x_50);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_51);
+return x_2;
+}
+else
+{
+lean_object* x_52; lean_object* x_53; 
+x_52 = l_Std_RBNode_ins___rarg(x_1, x_43, x_3, x_4);
+x_53 = lean_ctor_get(x_52, 0);
+lean_inc(x_53);
+if (lean_obj_tag(x_53) == 0)
+{
+lean_object* x_54; 
+x_54 = lean_ctor_get(x_52, 3);
+lean_inc(x_54);
+if (lean_obj_tag(x_54) == 0)
+{
+uint8_t x_55; 
+x_55 = !lean_is_exclusive(x_52);
+if (x_55 == 0)
+{
+lean_object* x_56; lean_object* x_57; uint8_t x_58; uint8_t x_59; 
+x_56 = lean_ctor_get(x_52, 3);
+lean_dec(x_56);
+x_57 = lean_ctor_get(x_52, 0);
+lean_dec(x_57);
+x_58 = 0;
+lean_ctor_set(x_52, 0, x_54);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_58);
+x_59 = 1;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_59);
+return x_2;
+}
+else
+{
+lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; uint8_t x_64; 
+x_60 = lean_ctor_get(x_52, 1);
+x_61 = lean_ctor_get(x_52, 2);
+lean_inc(x_61);
+lean_inc(x_60);
+lean_dec(x_52);
+x_62 = 0;
+x_63 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_63, 0, x_54);
+lean_ctor_set(x_63, 1, x_60);
+lean_ctor_set(x_63, 2, x_61);
+lean_ctor_set(x_63, 3, x_54);
+lean_ctor_set_uint8(x_63, sizeof(void*)*4, x_62);
+x_64 = 1;
+lean_ctor_set(x_2, 3, x_63);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_64);
+return x_2;
+}
+}
+else
+{
+uint8_t x_65; 
+x_65 = lean_ctor_get_uint8(x_54, sizeof(void*)*4);
+if (x_65 == 0)
+{
+uint8_t x_66; 
+x_66 = !lean_is_exclusive(x_52);
+if (x_66 == 0)
+{
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
+x_67 = lean_ctor_get(x_52, 1);
+x_68 = lean_ctor_get(x_52, 2);
+x_69 = lean_ctor_get(x_52, 3);
+lean_dec(x_69);
+x_70 = lean_ctor_get(x_52, 0);
+lean_dec(x_70);
+x_71 = !lean_is_exclusive(x_54);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; uint8_t x_77; 
+x_72 = lean_ctor_get(x_54, 0);
+x_73 = lean_ctor_get(x_54, 1);
+x_74 = lean_ctor_get(x_54, 2);
+x_75 = lean_ctor_get(x_54, 3);
+x_76 = 1;
+lean_ctor_set(x_54, 3, x_53);
+lean_ctor_set(x_54, 2, x_42);
+lean_ctor_set(x_54, 1, x_41);
+lean_ctor_set(x_54, 0, x_40);
+lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_76);
+lean_ctor_set(x_52, 3, x_75);
+lean_ctor_set(x_52, 2, x_74);
+lean_ctor_set(x_52, 1, x_73);
+lean_ctor_set(x_52, 0, x_72);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_76);
+x_77 = 0;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set(x_2, 2, x_68);
+lean_ctor_set(x_2, 1, x_67);
+lean_ctor_set(x_2, 0, x_54);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_77);
+return x_2;
+}
+else
+{
+lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; lean_object* x_83; uint8_t x_84; 
+x_78 = lean_ctor_get(x_54, 0);
+x_79 = lean_ctor_get(x_54, 1);
+x_80 = lean_ctor_get(x_54, 2);
+x_81 = lean_ctor_get(x_54, 3);
+lean_inc(x_81);
+lean_inc(x_80);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_dec(x_54);
+x_82 = 1;
+x_83 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_83, 0, x_40);
+lean_ctor_set(x_83, 1, x_41);
+lean_ctor_set(x_83, 2, x_42);
+lean_ctor_set(x_83, 3, x_53);
+lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_82);
+lean_ctor_set(x_52, 3, x_81);
+lean_ctor_set(x_52, 2, x_80);
+lean_ctor_set(x_52, 1, x_79);
+lean_ctor_set(x_52, 0, x_78);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_82);
+x_84 = 0;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set(x_2, 2, x_68);
+lean_ctor_set(x_2, 1, x_67);
+lean_ctor_set(x_2, 0, x_83);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_84);
+return x_2;
+}
+}
+else
+{
+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; uint8_t x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; 
+x_85 = lean_ctor_get(x_52, 1);
+x_86 = lean_ctor_get(x_52, 2);
+lean_inc(x_86);
+lean_inc(x_85);
+lean_dec(x_52);
+x_87 = lean_ctor_get(x_54, 0);
+lean_inc(x_87);
+x_88 = lean_ctor_get(x_54, 1);
+lean_inc(x_88);
+x_89 = lean_ctor_get(x_54, 2);
+lean_inc(x_89);
+x_90 = lean_ctor_get(x_54, 3);
+lean_inc(x_90);
+if (lean_is_exclusive(x_54)) {
+ lean_ctor_release(x_54, 0);
+ lean_ctor_release(x_54, 1);
+ lean_ctor_release(x_54, 2);
+ lean_ctor_release(x_54, 3);
+ x_91 = x_54;
+} else {
+ lean_dec_ref(x_54);
+ x_91 = lean_box(0);
+}
+x_92 = 1;
+if (lean_is_scalar(x_91)) {
+ x_93 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_93 = x_91;
+}
+lean_ctor_set(x_93, 0, x_40);
+lean_ctor_set(x_93, 1, x_41);
+lean_ctor_set(x_93, 2, x_42);
+lean_ctor_set(x_93, 3, x_53);
+lean_ctor_set_uint8(x_93, sizeof(void*)*4, x_92);
+x_94 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_94, 0, x_87);
+lean_ctor_set(x_94, 1, x_88);
+lean_ctor_set(x_94, 2, x_89);
+lean_ctor_set(x_94, 3, x_90);
+lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_92);
+x_95 = 0;
+lean_ctor_set(x_2, 3, x_94);
+lean_ctor_set(x_2, 2, x_86);
+lean_ctor_set(x_2, 1, x_85);
+lean_ctor_set(x_2, 0, x_93);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_95);
+return x_2;
+}
+}
+else
+{
+uint8_t x_96; 
+x_96 = !lean_is_exclusive(x_52);
+if (x_96 == 0)
+{
+lean_object* x_97; lean_object* x_98; uint8_t x_99; uint8_t x_100; 
+x_97 = lean_ctor_get(x_52, 3);
+lean_dec(x_97);
+x_98 = lean_ctor_get(x_52, 0);
+lean_dec(x_98);
+x_99 = 0;
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_99);
+x_100 = 1;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_100);
+return x_2;
+}
+else
+{
+lean_object* x_101; lean_object* x_102; uint8_t x_103; lean_object* x_104; uint8_t x_105; 
+x_101 = lean_ctor_get(x_52, 1);
+x_102 = lean_ctor_get(x_52, 2);
+lean_inc(x_102);
+lean_inc(x_101);
+lean_dec(x_52);
+x_103 = 0;
+x_104 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_104, 0, x_53);
+lean_ctor_set(x_104, 1, x_101);
+lean_ctor_set(x_104, 2, x_102);
+lean_ctor_set(x_104, 3, x_54);
+lean_ctor_set_uint8(x_104, sizeof(void*)*4, x_103);
+x_105 = 1;
+lean_ctor_set(x_2, 3, x_104);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_105);
+return x_2;
+}
+}
+}
+}
+else
+{
+uint8_t x_106; 
+x_106 = lean_ctor_get_uint8(x_53, sizeof(void*)*4);
+if (x_106 == 0)
+{
+uint8_t x_107; 
+x_107 = !lean_is_exclusive(x_52);
+if (x_107 == 0)
+{
+lean_object* x_108; uint8_t x_109; 
+x_108 = lean_ctor_get(x_52, 0);
+lean_dec(x_108);
+x_109 = !lean_is_exclusive(x_53);
+if (x_109 == 0)
+{
+lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; uint8_t x_114; uint8_t x_115; 
+x_110 = lean_ctor_get(x_53, 0);
+x_111 = lean_ctor_get(x_53, 1);
+x_112 = lean_ctor_get(x_53, 2);
+x_113 = lean_ctor_get(x_53, 3);
+x_114 = 1;
+lean_ctor_set(x_53, 3, x_110);
+lean_ctor_set(x_53, 2, x_42);
+lean_ctor_set(x_53, 1, x_41);
+lean_ctor_set(x_53, 0, x_40);
+lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_114);
+lean_ctor_set(x_52, 0, x_113);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_114);
+x_115 = 0;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set(x_2, 2, x_112);
+lean_ctor_set(x_2, 1, x_111);
+lean_ctor_set(x_2, 0, x_53);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_115);
+return x_2;
+}
+else
+{
+lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; uint8_t x_120; lean_object* x_121; uint8_t x_122; 
+x_116 = lean_ctor_get(x_53, 0);
+x_117 = lean_ctor_get(x_53, 1);
+x_118 = lean_ctor_get(x_53, 2);
+x_119 = lean_ctor_get(x_53, 3);
+lean_inc(x_119);
+lean_inc(x_118);
+lean_inc(x_117);
+lean_inc(x_116);
+lean_dec(x_53);
+x_120 = 1;
+x_121 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_121, 0, x_40);
+lean_ctor_set(x_121, 1, x_41);
+lean_ctor_set(x_121, 2, x_42);
+lean_ctor_set(x_121, 3, x_116);
+lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_120);
+lean_ctor_set(x_52, 0, x_119);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_120);
+x_122 = 0;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set(x_2, 2, x_118);
+lean_ctor_set(x_2, 1, x_117);
+lean_ctor_set(x_2, 0, x_121);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_122);
+return x_2;
+}
+}
+else
+{
+lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; 
+x_123 = lean_ctor_get(x_52, 1);
+x_124 = lean_ctor_get(x_52, 2);
+x_125 = lean_ctor_get(x_52, 3);
+lean_inc(x_125);
+lean_inc(x_124);
+lean_inc(x_123);
+lean_dec(x_52);
+x_126 = lean_ctor_get(x_53, 0);
+lean_inc(x_126);
+x_127 = lean_ctor_get(x_53, 1);
+lean_inc(x_127);
+x_128 = lean_ctor_get(x_53, 2);
+lean_inc(x_128);
+x_129 = lean_ctor_get(x_53, 3);
+lean_inc(x_129);
+if (lean_is_exclusive(x_53)) {
+ lean_ctor_release(x_53, 0);
+ lean_ctor_release(x_53, 1);
+ lean_ctor_release(x_53, 2);
+ lean_ctor_release(x_53, 3);
+ x_130 = x_53;
+} else {
+ lean_dec_ref(x_53);
+ x_130 = lean_box(0);
+}
+x_131 = 1;
+if (lean_is_scalar(x_130)) {
+ x_132 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_132 = x_130;
+}
+lean_ctor_set(x_132, 0, x_40);
+lean_ctor_set(x_132, 1, x_41);
+lean_ctor_set(x_132, 2, x_42);
+lean_ctor_set(x_132, 3, x_126);
+lean_ctor_set_uint8(x_132, sizeof(void*)*4, x_131);
+x_133 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_133, 0, x_129);
+lean_ctor_set(x_133, 1, x_123);
+lean_ctor_set(x_133, 2, x_124);
+lean_ctor_set(x_133, 3, x_125);
+lean_ctor_set_uint8(x_133, sizeof(void*)*4, x_131);
+x_134 = 0;
+lean_ctor_set(x_2, 3, x_133);
+lean_ctor_set(x_2, 2, x_128);
+lean_ctor_set(x_2, 1, x_127);
+lean_ctor_set(x_2, 0, x_132);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_134);
+return x_2;
+}
+}
+else
+{
+lean_object* x_135; 
+x_135 = lean_ctor_get(x_52, 3);
+lean_inc(x_135);
+if (lean_obj_tag(x_135) == 0)
+{
+uint8_t x_136; 
+x_136 = !lean_is_exclusive(x_52);
+if (x_136 == 0)
+{
+lean_object* x_137; lean_object* x_138; uint8_t x_139; uint8_t x_140; 
+x_137 = lean_ctor_get(x_52, 3);
+lean_dec(x_137);
+x_138 = lean_ctor_get(x_52, 0);
+lean_dec(x_138);
+x_139 = 0;
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_139);
+x_140 = 1;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_140);
+return x_2;
+}
+else
+{
+lean_object* x_141; lean_object* x_142; uint8_t x_143; lean_object* x_144; uint8_t x_145; 
+x_141 = lean_ctor_get(x_52, 1);
+x_142 = lean_ctor_get(x_52, 2);
+lean_inc(x_142);
+lean_inc(x_141);
+lean_dec(x_52);
+x_143 = 0;
+x_144 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_144, 0, x_53);
+lean_ctor_set(x_144, 1, x_141);
+lean_ctor_set(x_144, 2, x_142);
+lean_ctor_set(x_144, 3, x_135);
+lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_143);
+x_145 = 1;
+lean_ctor_set(x_2, 3, x_144);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_145);
+return x_2;
+}
+}
+else
+{
+uint8_t x_146; 
+x_146 = lean_ctor_get_uint8(x_135, sizeof(void*)*4);
+if (x_146 == 0)
+{
+uint8_t x_147; 
+lean_free_object(x_2);
+x_147 = !lean_is_exclusive(x_52);
+if (x_147 == 0)
+{
+lean_object* x_148; lean_object* x_149; uint8_t x_150; 
+x_148 = lean_ctor_get(x_52, 3);
+lean_dec(x_148);
+x_149 = lean_ctor_get(x_52, 0);
+lean_dec(x_149);
+x_150 = !lean_is_exclusive(x_135);
+if (x_150 == 0)
+{
+lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; uint8_t x_156; 
+x_151 = lean_ctor_get(x_135, 0);
+x_152 = lean_ctor_get(x_135, 1);
+x_153 = lean_ctor_get(x_135, 2);
+x_154 = lean_ctor_get(x_135, 3);
+x_155 = 1;
+lean_inc(x_53);
+lean_ctor_set(x_135, 3, x_53);
+lean_ctor_set(x_135, 2, x_42);
+lean_ctor_set(x_135, 1, x_41);
+lean_ctor_set(x_135, 0, x_40);
+x_156 = !lean_is_exclusive(x_53);
+if (x_156 == 0)
+{
+lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; uint8_t x_161; 
+x_157 = lean_ctor_get(x_53, 3);
+lean_dec(x_157);
+x_158 = lean_ctor_get(x_53, 2);
+lean_dec(x_158);
+x_159 = lean_ctor_get(x_53, 1);
+lean_dec(x_159);
+x_160 = lean_ctor_get(x_53, 0);
+lean_dec(x_160);
+lean_ctor_set_uint8(x_135, sizeof(void*)*4, x_155);
+lean_ctor_set(x_53, 3, x_154);
+lean_ctor_set(x_53, 2, x_153);
+lean_ctor_set(x_53, 1, x_152);
+lean_ctor_set(x_53, 0, x_151);
+lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_155);
+x_161 = 0;
+lean_ctor_set(x_52, 3, x_53);
+lean_ctor_set(x_52, 0, x_135);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_161);
+return x_52;
+}
+else
+{
+lean_object* x_162; uint8_t x_163; 
+lean_dec(x_53);
+lean_ctor_set_uint8(x_135, sizeof(void*)*4, x_155);
+x_162 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_162, 0, x_151);
+lean_ctor_set(x_162, 1, x_152);
+lean_ctor_set(x_162, 2, x_153);
+lean_ctor_set(x_162, 3, x_154);
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_155);
+x_163 = 0;
+lean_ctor_set(x_52, 3, x_162);
+lean_ctor_set(x_52, 0, x_135);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_163);
+return x_52;
+}
+}
+else
+{
+lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; uint8_t x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; 
+x_164 = lean_ctor_get(x_135, 0);
+x_165 = lean_ctor_get(x_135, 1);
+x_166 = lean_ctor_get(x_135, 2);
+x_167 = lean_ctor_get(x_135, 3);
+lean_inc(x_167);
+lean_inc(x_166);
+lean_inc(x_165);
+lean_inc(x_164);
+lean_dec(x_135);
+x_168 = 1;
+lean_inc(x_53);
+x_169 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_169, 0, x_40);
+lean_ctor_set(x_169, 1, x_41);
+lean_ctor_set(x_169, 2, x_42);
+lean_ctor_set(x_169, 3, x_53);
+if (lean_is_exclusive(x_53)) {
+ lean_ctor_release(x_53, 0);
+ lean_ctor_release(x_53, 1);
+ lean_ctor_release(x_53, 2);
+ lean_ctor_release(x_53, 3);
+ x_170 = x_53;
+} else {
+ lean_dec_ref(x_53);
+ x_170 = lean_box(0);
+}
+lean_ctor_set_uint8(x_169, sizeof(void*)*4, x_168);
+if (lean_is_scalar(x_170)) {
+ x_171 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_171 = x_170;
+}
+lean_ctor_set(x_171, 0, x_164);
+lean_ctor_set(x_171, 1, x_165);
+lean_ctor_set(x_171, 2, x_166);
+lean_ctor_set(x_171, 3, x_167);
+lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_168);
+x_172 = 0;
+lean_ctor_set(x_52, 3, x_171);
+lean_ctor_set(x_52, 0, x_169);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_172);
+return x_52;
+}
+}
+else
+{
+lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; uint8_t x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; uint8_t x_184; lean_object* x_185; 
+x_173 = lean_ctor_get(x_52, 1);
+x_174 = lean_ctor_get(x_52, 2);
+lean_inc(x_174);
+lean_inc(x_173);
+lean_dec(x_52);
+x_175 = lean_ctor_get(x_135, 0);
+lean_inc(x_175);
+x_176 = lean_ctor_get(x_135, 1);
+lean_inc(x_176);
+x_177 = lean_ctor_get(x_135, 2);
+lean_inc(x_177);
+x_178 = lean_ctor_get(x_135, 3);
+lean_inc(x_178);
+if (lean_is_exclusive(x_135)) {
+ lean_ctor_release(x_135, 0);
+ lean_ctor_release(x_135, 1);
+ lean_ctor_release(x_135, 2);
+ lean_ctor_release(x_135, 3);
+ x_179 = x_135;
+} else {
+ lean_dec_ref(x_135);
+ x_179 = lean_box(0);
+}
+x_180 = 1;
+lean_inc(x_53);
+if (lean_is_scalar(x_179)) {
+ x_181 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_181 = x_179;
+}
+lean_ctor_set(x_181, 0, x_40);
+lean_ctor_set(x_181, 1, x_41);
+lean_ctor_set(x_181, 2, x_42);
+lean_ctor_set(x_181, 3, x_53);
+if (lean_is_exclusive(x_53)) {
+ lean_ctor_release(x_53, 0);
+ lean_ctor_release(x_53, 1);
+ lean_ctor_release(x_53, 2);
+ lean_ctor_release(x_53, 3);
+ x_182 = x_53;
+} else {
+ lean_dec_ref(x_53);
+ x_182 = lean_box(0);
+}
+lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_180);
+if (lean_is_scalar(x_182)) {
+ x_183 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_183 = x_182;
+}
+lean_ctor_set(x_183, 0, x_175);
+lean_ctor_set(x_183, 1, x_176);
+lean_ctor_set(x_183, 2, x_177);
+lean_ctor_set(x_183, 3, x_178);
+lean_ctor_set_uint8(x_183, sizeof(void*)*4, x_180);
+x_184 = 0;
+x_185 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_185, 0, x_181);
+lean_ctor_set(x_185, 1, x_173);
+lean_ctor_set(x_185, 2, x_174);
+lean_ctor_set(x_185, 3, x_183);
+lean_ctor_set_uint8(x_185, sizeof(void*)*4, x_184);
+return x_185;
+}
+}
+else
+{
+uint8_t x_186; 
+x_186 = !lean_is_exclusive(x_52);
+if (x_186 == 0)
+{
+lean_object* x_187; lean_object* x_188; uint8_t x_189; 
+x_187 = lean_ctor_get(x_52, 3);
+lean_dec(x_187);
+x_188 = lean_ctor_get(x_52, 0);
+lean_dec(x_188);
+x_189 = !lean_is_exclusive(x_53);
+if (x_189 == 0)
+{
+uint8_t x_190; uint8_t x_191; 
+lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_146);
+x_190 = 0;
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_190);
+x_191 = 1;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_191);
+return x_2;
+}
+else
+{
+lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; uint8_t x_197; uint8_t x_198; 
+x_192 = lean_ctor_get(x_53, 0);
+x_193 = lean_ctor_get(x_53, 1);
+x_194 = lean_ctor_get(x_53, 2);
+x_195 = lean_ctor_get(x_53, 3);
+lean_inc(x_195);
+lean_inc(x_194);
+lean_inc(x_193);
+lean_inc(x_192);
+lean_dec(x_53);
+x_196 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_196, 0, x_192);
+lean_ctor_set(x_196, 1, x_193);
+lean_ctor_set(x_196, 2, x_194);
+lean_ctor_set(x_196, 3, x_195);
+lean_ctor_set_uint8(x_196, sizeof(void*)*4, x_146);
+x_197 = 0;
+lean_ctor_set(x_52, 0, x_196);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_197);
+x_198 = 1;
+lean_ctor_set(x_2, 3, x_52);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_198);
+return x_2;
+}
+}
+else
+{
+lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; uint8_t x_207; lean_object* x_208; uint8_t x_209; 
+x_199 = lean_ctor_get(x_52, 1);
+x_200 = lean_ctor_get(x_52, 2);
+lean_inc(x_200);
+lean_inc(x_199);
+lean_dec(x_52);
+x_201 = lean_ctor_get(x_53, 0);
+lean_inc(x_201);
+x_202 = lean_ctor_get(x_53, 1);
+lean_inc(x_202);
+x_203 = lean_ctor_get(x_53, 2);
+lean_inc(x_203);
+x_204 = lean_ctor_get(x_53, 3);
+lean_inc(x_204);
+if (lean_is_exclusive(x_53)) {
+ lean_ctor_release(x_53, 0);
+ lean_ctor_release(x_53, 1);
+ lean_ctor_release(x_53, 2);
+ lean_ctor_release(x_53, 3);
+ x_205 = x_53;
+} else {
+ lean_dec_ref(x_53);
+ x_205 = lean_box(0);
+}
+if (lean_is_scalar(x_205)) {
+ x_206 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_206 = x_205;
+}
+lean_ctor_set(x_206, 0, x_201);
+lean_ctor_set(x_206, 1, x_202);
+lean_ctor_set(x_206, 2, x_203);
+lean_ctor_set(x_206, 3, x_204);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_146);
+x_207 = 0;
+x_208 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_208, 0, x_206);
+lean_ctor_set(x_208, 1, x_199);
+lean_ctor_set(x_208, 2, x_200);
+lean_ctor_set(x_208, 3, x_135);
+lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_207);
+x_209 = 1;
+lean_ctor_set(x_2, 3, x_208);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_209);
+return x_2;
+}
+}
+}
+}
+}
+}
+}
+}
+else
+{
+uint8_t x_210; 
+x_210 = l_Std_RBNode_isRed___rarg(x_40);
+if (x_210 == 0)
+{
+lean_object* x_211; uint8_t x_212; 
+x_211 = l_Std_RBNode_ins___rarg(x_1, x_40, x_3, x_4);
+x_212 = 1;
+lean_ctor_set(x_2, 0, x_211);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_212);
+return x_2;
+}
+else
+{
+lean_object* x_213; lean_object* x_214; 
+x_213 = l_Std_RBNode_ins___rarg(x_1, x_40, x_3, x_4);
+x_214 = lean_ctor_get(x_213, 0);
+lean_inc(x_214);
+if (lean_obj_tag(x_214) == 0)
+{
+lean_object* x_215; 
+x_215 = lean_ctor_get(x_213, 3);
+lean_inc(x_215);
+if (lean_obj_tag(x_215) == 0)
+{
+uint8_t x_216; 
+x_216 = !lean_is_exclusive(x_213);
+if (x_216 == 0)
+{
+lean_object* x_217; lean_object* x_218; uint8_t x_219; uint8_t x_220; 
+x_217 = lean_ctor_get(x_213, 3);
+lean_dec(x_217);
+x_218 = lean_ctor_get(x_213, 0);
+lean_dec(x_218);
+x_219 = 0;
+lean_ctor_set(x_213, 0, x_215);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_219);
+x_220 = 1;
+lean_ctor_set(x_2, 0, x_213);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_220);
+return x_2;
+}
+else
+{
+lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; uint8_t x_225; 
+x_221 = lean_ctor_get(x_213, 1);
+x_222 = lean_ctor_get(x_213, 2);
+lean_inc(x_222);
+lean_inc(x_221);
+lean_dec(x_213);
+x_223 = 0;
+x_224 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_224, 0, x_215);
+lean_ctor_set(x_224, 1, x_221);
+lean_ctor_set(x_224, 2, x_222);
+lean_ctor_set(x_224, 3, x_215);
+lean_ctor_set_uint8(x_224, sizeof(void*)*4, x_223);
+x_225 = 1;
+lean_ctor_set(x_2, 0, x_224);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_225);
+return x_2;
+}
+}
+else
+{
+uint8_t x_226; 
+x_226 = lean_ctor_get_uint8(x_215, sizeof(void*)*4);
+if (x_226 == 0)
+{
+uint8_t x_227; 
+x_227 = !lean_is_exclusive(x_213);
+if (x_227 == 0)
+{
+lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; uint8_t x_232; 
+x_228 = lean_ctor_get(x_213, 1);
+x_229 = lean_ctor_get(x_213, 2);
+x_230 = lean_ctor_get(x_213, 3);
+lean_dec(x_230);
+x_231 = lean_ctor_get(x_213, 0);
+lean_dec(x_231);
+x_232 = !lean_is_exclusive(x_215);
+if (x_232 == 0)
+{
+lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; uint8_t x_237; uint8_t x_238; 
+x_233 = lean_ctor_get(x_215, 0);
+x_234 = lean_ctor_get(x_215, 1);
+x_235 = lean_ctor_get(x_215, 2);
+x_236 = lean_ctor_get(x_215, 3);
+x_237 = 1;
+lean_ctor_set(x_215, 3, x_233);
+lean_ctor_set(x_215, 2, x_229);
+lean_ctor_set(x_215, 1, x_228);
+lean_ctor_set(x_215, 0, x_214);
+lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_237);
+lean_ctor_set(x_213, 3, x_43);
+lean_ctor_set(x_213, 2, x_42);
+lean_ctor_set(x_213, 1, x_41);
+lean_ctor_set(x_213, 0, x_236);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_237);
+x_238 = 0;
+lean_ctor_set(x_2, 3, x_213);
+lean_ctor_set(x_2, 2, x_235);
+lean_ctor_set(x_2, 1, x_234);
+lean_ctor_set(x_2, 0, x_215);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_238);
+return x_2;
+}
+else
+{
+lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; uint8_t x_243; lean_object* x_244; uint8_t x_245; 
+x_239 = lean_ctor_get(x_215, 0);
+x_240 = lean_ctor_get(x_215, 1);
+x_241 = lean_ctor_get(x_215, 2);
+x_242 = lean_ctor_get(x_215, 3);
+lean_inc(x_242);
+lean_inc(x_241);
+lean_inc(x_240);
+lean_inc(x_239);
+lean_dec(x_215);
+x_243 = 1;
+x_244 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_244, 0, x_214);
+lean_ctor_set(x_244, 1, x_228);
+lean_ctor_set(x_244, 2, x_229);
+lean_ctor_set(x_244, 3, x_239);
+lean_ctor_set_uint8(x_244, sizeof(void*)*4, x_243);
+lean_ctor_set(x_213, 3, x_43);
+lean_ctor_set(x_213, 2, x_42);
+lean_ctor_set(x_213, 1, x_41);
+lean_ctor_set(x_213, 0, x_242);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_243);
+x_245 = 0;
+lean_ctor_set(x_2, 3, x_213);
+lean_ctor_set(x_2, 2, x_241);
+lean_ctor_set(x_2, 1, x_240);
+lean_ctor_set(x_2, 0, x_244);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_245);
+return x_2;
+}
+}
+else
+{
+lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; uint8_t x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; 
+x_246 = lean_ctor_get(x_213, 1);
+x_247 = lean_ctor_get(x_213, 2);
+lean_inc(x_247);
+lean_inc(x_246);
+lean_dec(x_213);
+x_248 = lean_ctor_get(x_215, 0);
+lean_inc(x_248);
+x_249 = lean_ctor_get(x_215, 1);
+lean_inc(x_249);
+x_250 = lean_ctor_get(x_215, 2);
+lean_inc(x_250);
+x_251 = lean_ctor_get(x_215, 3);
+lean_inc(x_251);
+if (lean_is_exclusive(x_215)) {
+ lean_ctor_release(x_215, 0);
+ lean_ctor_release(x_215, 1);
+ lean_ctor_release(x_215, 2);
+ lean_ctor_release(x_215, 3);
+ x_252 = x_215;
+} else {
+ lean_dec_ref(x_215);
+ x_252 = lean_box(0);
+}
+x_253 = 1;
+if (lean_is_scalar(x_252)) {
+ x_254 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_254 = x_252;
+}
+lean_ctor_set(x_254, 0, x_214);
+lean_ctor_set(x_254, 1, x_246);
+lean_ctor_set(x_254, 2, x_247);
+lean_ctor_set(x_254, 3, x_248);
+lean_ctor_set_uint8(x_254, sizeof(void*)*4, x_253);
+x_255 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_255, 0, x_251);
+lean_ctor_set(x_255, 1, x_41);
+lean_ctor_set(x_255, 2, x_42);
+lean_ctor_set(x_255, 3, x_43);
+lean_ctor_set_uint8(x_255, sizeof(void*)*4, x_253);
+x_256 = 0;
+lean_ctor_set(x_2, 3, x_255);
+lean_ctor_set(x_2, 2, x_250);
+lean_ctor_set(x_2, 1, x_249);
+lean_ctor_set(x_2, 0, x_254);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_256);
+return x_2;
+}
+}
+else
+{
+uint8_t x_257; 
+x_257 = !lean_is_exclusive(x_213);
+if (x_257 == 0)
+{
+lean_object* x_258; lean_object* x_259; uint8_t x_260; uint8_t x_261; 
+x_258 = lean_ctor_get(x_213, 3);
+lean_dec(x_258);
+x_259 = lean_ctor_get(x_213, 0);
+lean_dec(x_259);
+x_260 = 0;
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_260);
+x_261 = 1;
+lean_ctor_set(x_2, 0, x_213);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_261);
+return x_2;
+}
+else
+{
+lean_object* x_262; lean_object* x_263; uint8_t x_264; lean_object* x_265; uint8_t x_266; 
+x_262 = lean_ctor_get(x_213, 1);
+x_263 = lean_ctor_get(x_213, 2);
+lean_inc(x_263);
+lean_inc(x_262);
+lean_dec(x_213);
+x_264 = 0;
+x_265 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_265, 0, x_214);
+lean_ctor_set(x_265, 1, x_262);
+lean_ctor_set(x_265, 2, x_263);
+lean_ctor_set(x_265, 3, x_215);
+lean_ctor_set_uint8(x_265, sizeof(void*)*4, x_264);
+x_266 = 1;
+lean_ctor_set(x_2, 0, x_265);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_266);
+return x_2;
+}
+}
+}
+}
+else
+{
+uint8_t x_267; 
+x_267 = lean_ctor_get_uint8(x_214, sizeof(void*)*4);
+if (x_267 == 0)
+{
+uint8_t x_268; 
+x_268 = !lean_is_exclusive(x_213);
+if (x_268 == 0)
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; 
+x_269 = lean_ctor_get(x_213, 1);
+x_270 = lean_ctor_get(x_213, 2);
+x_271 = lean_ctor_get(x_213, 3);
+x_272 = lean_ctor_get(x_213, 0);
+lean_dec(x_272);
+x_273 = !lean_is_exclusive(x_214);
+if (x_273 == 0)
+{
+uint8_t x_274; uint8_t x_275; 
+x_274 = 1;
+lean_ctor_set_uint8(x_214, sizeof(void*)*4, x_274);
+lean_ctor_set(x_213, 3, x_43);
+lean_ctor_set(x_213, 2, x_42);
+lean_ctor_set(x_213, 1, x_41);
+lean_ctor_set(x_213, 0, x_271);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_274);
+x_275 = 0;
+lean_ctor_set(x_2, 3, x_213);
+lean_ctor_set(x_2, 2, x_270);
+lean_ctor_set(x_2, 1, x_269);
+lean_ctor_set(x_2, 0, x_214);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_275);
+return x_2;
+}
+else
+{
+lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; uint8_t x_280; lean_object* x_281; uint8_t x_282; 
+x_276 = lean_ctor_get(x_214, 0);
+x_277 = lean_ctor_get(x_214, 1);
+x_278 = lean_ctor_get(x_214, 2);
+x_279 = lean_ctor_get(x_214, 3);
+lean_inc(x_279);
+lean_inc(x_278);
+lean_inc(x_277);
+lean_inc(x_276);
+lean_dec(x_214);
+x_280 = 1;
+x_281 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_281, 0, x_276);
+lean_ctor_set(x_281, 1, x_277);
+lean_ctor_set(x_281, 2, x_278);
+lean_ctor_set(x_281, 3, x_279);
+lean_ctor_set_uint8(x_281, sizeof(void*)*4, x_280);
+lean_ctor_set(x_213, 3, x_43);
+lean_ctor_set(x_213, 2, x_42);
+lean_ctor_set(x_213, 1, x_41);
+lean_ctor_set(x_213, 0, x_271);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_280);
+x_282 = 0;
+lean_ctor_set(x_2, 3, x_213);
+lean_ctor_set(x_2, 2, x_270);
+lean_ctor_set(x_2, 1, x_269);
+lean_ctor_set(x_2, 0, x_281);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_282);
+return x_2;
+}
+}
+else
+{
+lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; uint8_t x_291; lean_object* x_292; lean_object* x_293; uint8_t x_294; 
+x_283 = lean_ctor_get(x_213, 1);
+x_284 = lean_ctor_get(x_213, 2);
+x_285 = lean_ctor_get(x_213, 3);
+lean_inc(x_285);
+lean_inc(x_284);
+lean_inc(x_283);
+lean_dec(x_213);
+x_286 = lean_ctor_get(x_214, 0);
+lean_inc(x_286);
+x_287 = lean_ctor_get(x_214, 1);
+lean_inc(x_287);
+x_288 = lean_ctor_get(x_214, 2);
+lean_inc(x_288);
+x_289 = lean_ctor_get(x_214, 3);
+lean_inc(x_289);
+if (lean_is_exclusive(x_214)) {
+ lean_ctor_release(x_214, 0);
+ lean_ctor_release(x_214, 1);
+ lean_ctor_release(x_214, 2);
+ lean_ctor_release(x_214, 3);
+ x_290 = x_214;
+} else {
+ lean_dec_ref(x_214);
+ x_290 = lean_box(0);
+}
+x_291 = 1;
+if (lean_is_scalar(x_290)) {
+ x_292 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_292 = x_290;
+}
+lean_ctor_set(x_292, 0, x_286);
+lean_ctor_set(x_292, 1, x_287);
+lean_ctor_set(x_292, 2, x_288);
+lean_ctor_set(x_292, 3, x_289);
+lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_291);
+x_293 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_293, 0, x_285);
+lean_ctor_set(x_293, 1, x_41);
+lean_ctor_set(x_293, 2, x_42);
+lean_ctor_set(x_293, 3, x_43);
+lean_ctor_set_uint8(x_293, sizeof(void*)*4, x_291);
+x_294 = 0;
+lean_ctor_set(x_2, 3, x_293);
+lean_ctor_set(x_2, 2, x_284);
+lean_ctor_set(x_2, 1, x_283);
+lean_ctor_set(x_2, 0, x_292);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_294);
+return x_2;
+}
+}
+else
+{
+lean_object* x_295; 
+x_295 = lean_ctor_get(x_213, 3);
+lean_inc(x_295);
+if (lean_obj_tag(x_295) == 0)
+{
+uint8_t x_296; 
+x_296 = !lean_is_exclusive(x_213);
+if (x_296 == 0)
+{
+lean_object* x_297; lean_object* x_298; uint8_t x_299; uint8_t x_300; 
+x_297 = lean_ctor_get(x_213, 3);
+lean_dec(x_297);
+x_298 = lean_ctor_get(x_213, 0);
+lean_dec(x_298);
+x_299 = 0;
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_299);
+x_300 = 1;
+lean_ctor_set(x_2, 0, x_213);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_300);
+return x_2;
+}
+else
+{
+lean_object* x_301; lean_object* x_302; uint8_t x_303; lean_object* x_304; uint8_t x_305; 
+x_301 = lean_ctor_get(x_213, 1);
+x_302 = lean_ctor_get(x_213, 2);
+lean_inc(x_302);
+lean_inc(x_301);
+lean_dec(x_213);
+x_303 = 0;
+x_304 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_304, 0, x_214);
+lean_ctor_set(x_304, 1, x_301);
+lean_ctor_set(x_304, 2, x_302);
+lean_ctor_set(x_304, 3, x_295);
+lean_ctor_set_uint8(x_304, sizeof(void*)*4, x_303);
+x_305 = 1;
+lean_ctor_set(x_2, 0, x_304);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_305);
+return x_2;
+}
+}
+else
+{
+uint8_t x_306; 
+x_306 = lean_ctor_get_uint8(x_295, sizeof(void*)*4);
+if (x_306 == 0)
+{
+uint8_t x_307; 
+lean_free_object(x_2);
+x_307 = !lean_is_exclusive(x_213);
+if (x_307 == 0)
+{
+lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; uint8_t x_312; 
+x_308 = lean_ctor_get(x_213, 1);
+x_309 = lean_ctor_get(x_213, 2);
+x_310 = lean_ctor_get(x_213, 3);
+lean_dec(x_310);
+x_311 = lean_ctor_get(x_213, 0);
+lean_dec(x_311);
+x_312 = !lean_is_exclusive(x_295);
+if (x_312 == 0)
+{
+lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; uint8_t x_317; uint8_t x_318; 
+x_313 = lean_ctor_get(x_295, 0);
+x_314 = lean_ctor_get(x_295, 1);
+x_315 = lean_ctor_get(x_295, 2);
+x_316 = lean_ctor_get(x_295, 3);
+x_317 = 1;
+lean_inc(x_214);
+lean_ctor_set(x_295, 3, x_313);
+lean_ctor_set(x_295, 2, x_309);
+lean_ctor_set(x_295, 1, x_308);
+lean_ctor_set(x_295, 0, x_214);
+x_318 = !lean_is_exclusive(x_214);
+if (x_318 == 0)
+{
+lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; 
+x_319 = lean_ctor_get(x_214, 3);
+lean_dec(x_319);
+x_320 = lean_ctor_get(x_214, 2);
+lean_dec(x_320);
+x_321 = lean_ctor_get(x_214, 1);
+lean_dec(x_321);
+x_322 = lean_ctor_get(x_214, 0);
+lean_dec(x_322);
+lean_ctor_set_uint8(x_295, sizeof(void*)*4, x_317);
+lean_ctor_set(x_214, 3, x_43);
+lean_ctor_set(x_214, 2, x_42);
+lean_ctor_set(x_214, 1, x_41);
+lean_ctor_set(x_214, 0, x_316);
+lean_ctor_set_uint8(x_214, sizeof(void*)*4, x_317);
+x_323 = 0;
+lean_ctor_set(x_213, 3, x_214);
+lean_ctor_set(x_213, 2, x_315);
+lean_ctor_set(x_213, 1, x_314);
+lean_ctor_set(x_213, 0, x_295);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_323);
+return x_213;
+}
+else
+{
+lean_object* x_324; uint8_t x_325; 
+lean_dec(x_214);
+lean_ctor_set_uint8(x_295, sizeof(void*)*4, x_317);
+x_324 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_324, 0, x_316);
+lean_ctor_set(x_324, 1, x_41);
+lean_ctor_set(x_324, 2, x_42);
+lean_ctor_set(x_324, 3, x_43);
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_317);
+x_325 = 0;
+lean_ctor_set(x_213, 3, x_324);
+lean_ctor_set(x_213, 2, x_315);
+lean_ctor_set(x_213, 1, x_314);
+lean_ctor_set(x_213, 0, x_295);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_325);
+return x_213;
+}
+}
+else
+{
+lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; uint8_t x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; uint8_t x_334; 
+x_326 = lean_ctor_get(x_295, 0);
+x_327 = lean_ctor_get(x_295, 1);
+x_328 = lean_ctor_get(x_295, 2);
+x_329 = lean_ctor_get(x_295, 3);
+lean_inc(x_329);
+lean_inc(x_328);
+lean_inc(x_327);
+lean_inc(x_326);
+lean_dec(x_295);
+x_330 = 1;
+lean_inc(x_214);
+x_331 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_331, 0, x_214);
+lean_ctor_set(x_331, 1, x_308);
+lean_ctor_set(x_331, 2, x_309);
+lean_ctor_set(x_331, 3, x_326);
+if (lean_is_exclusive(x_214)) {
+ lean_ctor_release(x_214, 0);
+ lean_ctor_release(x_214, 1);
+ lean_ctor_release(x_214, 2);
+ lean_ctor_release(x_214, 3);
+ x_332 = x_214;
+} else {
+ lean_dec_ref(x_214);
+ x_332 = lean_box(0);
+}
+lean_ctor_set_uint8(x_331, sizeof(void*)*4, x_330);
+if (lean_is_scalar(x_332)) {
+ x_333 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_333 = x_332;
+}
+lean_ctor_set(x_333, 0, x_329);
+lean_ctor_set(x_333, 1, x_41);
+lean_ctor_set(x_333, 2, x_42);
+lean_ctor_set(x_333, 3, x_43);
+lean_ctor_set_uint8(x_333, sizeof(void*)*4, x_330);
+x_334 = 0;
+lean_ctor_set(x_213, 3, x_333);
+lean_ctor_set(x_213, 2, x_328);
+lean_ctor_set(x_213, 1, x_327);
+lean_ctor_set(x_213, 0, x_331);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_334);
+return x_213;
+}
+}
+else
+{
+lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; uint8_t x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; uint8_t x_346; lean_object* x_347; 
+x_335 = lean_ctor_get(x_213, 1);
+x_336 = lean_ctor_get(x_213, 2);
+lean_inc(x_336);
+lean_inc(x_335);
+lean_dec(x_213);
+x_337 = lean_ctor_get(x_295, 0);
+lean_inc(x_337);
+x_338 = lean_ctor_get(x_295, 1);
+lean_inc(x_338);
+x_339 = lean_ctor_get(x_295, 2);
+lean_inc(x_339);
+x_340 = lean_ctor_get(x_295, 3);
+lean_inc(x_340);
+if (lean_is_exclusive(x_295)) {
+ lean_ctor_release(x_295, 0);
+ lean_ctor_release(x_295, 1);
+ lean_ctor_release(x_295, 2);
+ lean_ctor_release(x_295, 3);
+ x_341 = x_295;
+} else {
+ lean_dec_ref(x_295);
+ x_341 = lean_box(0);
+}
+x_342 = 1;
+lean_inc(x_214);
+if (lean_is_scalar(x_341)) {
+ x_343 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_343 = x_341;
+}
+lean_ctor_set(x_343, 0, x_214);
+lean_ctor_set(x_343, 1, x_335);
+lean_ctor_set(x_343, 2, x_336);
+lean_ctor_set(x_343, 3, x_337);
+if (lean_is_exclusive(x_214)) {
+ lean_ctor_release(x_214, 0);
+ lean_ctor_release(x_214, 1);
+ lean_ctor_release(x_214, 2);
+ lean_ctor_release(x_214, 3);
+ x_344 = x_214;
+} else {
+ lean_dec_ref(x_214);
+ x_344 = lean_box(0);
+}
+lean_ctor_set_uint8(x_343, sizeof(void*)*4, x_342);
+if (lean_is_scalar(x_344)) {
+ x_345 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_345 = x_344;
+}
+lean_ctor_set(x_345, 0, x_340);
+lean_ctor_set(x_345, 1, x_41);
+lean_ctor_set(x_345, 2, x_42);
+lean_ctor_set(x_345, 3, x_43);
+lean_ctor_set_uint8(x_345, sizeof(void*)*4, x_342);
+x_346 = 0;
+x_347 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_347, 0, x_343);
+lean_ctor_set(x_347, 1, x_338);
+lean_ctor_set(x_347, 2, x_339);
+lean_ctor_set(x_347, 3, x_345);
+lean_ctor_set_uint8(x_347, sizeof(void*)*4, x_346);
+return x_347;
+}
+}
+else
+{
+uint8_t x_348; 
+x_348 = !lean_is_exclusive(x_213);
+if (x_348 == 0)
+{
+lean_object* x_349; lean_object* x_350; uint8_t x_351; 
+x_349 = lean_ctor_get(x_213, 3);
+lean_dec(x_349);
+x_350 = lean_ctor_get(x_213, 0);
+lean_dec(x_350);
+x_351 = !lean_is_exclusive(x_214);
+if (x_351 == 0)
+{
+uint8_t x_352; uint8_t x_353; 
+lean_ctor_set_uint8(x_214, sizeof(void*)*4, x_306);
+x_352 = 0;
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_352);
+x_353 = 1;
+lean_ctor_set(x_2, 0, x_213);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_353);
+return x_2;
+}
+else
+{
+lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; uint8_t x_359; uint8_t x_360; 
+x_354 = lean_ctor_get(x_214, 0);
+x_355 = lean_ctor_get(x_214, 1);
+x_356 = lean_ctor_get(x_214, 2);
+x_357 = lean_ctor_get(x_214, 3);
+lean_inc(x_357);
+lean_inc(x_356);
+lean_inc(x_355);
+lean_inc(x_354);
+lean_dec(x_214);
+x_358 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_358, 0, x_354);
+lean_ctor_set(x_358, 1, x_355);
+lean_ctor_set(x_358, 2, x_356);
+lean_ctor_set(x_358, 3, x_357);
+lean_ctor_set_uint8(x_358, sizeof(void*)*4, x_306);
+x_359 = 0;
+lean_ctor_set(x_213, 0, x_358);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_359);
+x_360 = 1;
+lean_ctor_set(x_2, 0, x_213);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_360);
+return x_2;
+}
+}
+else
+{
+lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; lean_object* x_370; uint8_t x_371; 
+x_361 = lean_ctor_get(x_213, 1);
+x_362 = lean_ctor_get(x_213, 2);
+lean_inc(x_362);
+lean_inc(x_361);
+lean_dec(x_213);
+x_363 = lean_ctor_get(x_214, 0);
+lean_inc(x_363);
+x_364 = lean_ctor_get(x_214, 1);
+lean_inc(x_364);
+x_365 = lean_ctor_get(x_214, 2);
+lean_inc(x_365);
+x_366 = lean_ctor_get(x_214, 3);
+lean_inc(x_366);
+if (lean_is_exclusive(x_214)) {
+ lean_ctor_release(x_214, 0);
+ lean_ctor_release(x_214, 1);
+ lean_ctor_release(x_214, 2);
+ lean_ctor_release(x_214, 3);
+ x_367 = x_214;
+} else {
+ lean_dec_ref(x_214);
+ x_367 = lean_box(0);
+}
+if (lean_is_scalar(x_367)) {
+ x_368 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_368 = x_367;
+}
+lean_ctor_set(x_368, 0, x_363);
+lean_ctor_set(x_368, 1, x_364);
+lean_ctor_set(x_368, 2, x_365);
+lean_ctor_set(x_368, 3, x_366);
+lean_ctor_set_uint8(x_368, sizeof(void*)*4, x_306);
+x_369 = 0;
+x_370 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_370, 0, x_368);
+lean_ctor_set(x_370, 1, x_361);
+lean_ctor_set(x_370, 2, x_362);
+lean_ctor_set(x_370, 3, x_295);
+lean_ctor_set_uint8(x_370, sizeof(void*)*4, x_369);
+x_371 = 1;
+lean_ctor_set(x_2, 0, x_370);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_371);
+return x_2;
+}
+}
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; uint8_t x_377; 
+x_372 = lean_ctor_get(x_2, 0);
+x_373 = lean_ctor_get(x_2, 1);
+x_374 = lean_ctor_get(x_2, 2);
+x_375 = lean_ctor_get(x_2, 3);
+lean_inc(x_375);
+lean_inc(x_374);
+lean_inc(x_373);
+lean_inc(x_372);
+lean_dec(x_2);
+lean_inc(x_1);
+lean_inc(x_373);
+lean_inc(x_3);
+x_376 = lean_apply_2(x_1, x_3, x_373);
+x_377 = lean_unbox(x_376);
+lean_dec(x_376);
+if (x_377 == 0)
+{
+lean_object* x_378; uint8_t x_379; 
+lean_inc(x_1);
+lean_inc(x_3);
+lean_inc(x_373);
+x_378 = lean_apply_2(x_1, x_373, x_3);
+x_379 = lean_unbox(x_378);
+lean_dec(x_378);
+if (x_379 == 0)
+{
+uint8_t x_380; lean_object* x_381; 
+lean_dec(x_374);
+lean_dec(x_373);
+lean_dec(x_1);
+x_380 = 1;
+x_381 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_381, 0, x_372);
+lean_ctor_set(x_381, 1, x_3);
+lean_ctor_set(x_381, 2, x_4);
+lean_ctor_set(x_381, 3, x_375);
+lean_ctor_set_uint8(x_381, sizeof(void*)*4, x_380);
+return x_381;
+}
+else
+{
+uint8_t x_382; 
+x_382 = l_Std_RBNode_isRed___rarg(x_375);
+if (x_382 == 0)
+{
+lean_object* x_383; uint8_t x_384; lean_object* x_385; 
+x_383 = l_Std_RBNode_ins___rarg(x_1, x_375, x_3, x_4);
+x_384 = 1;
+x_385 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_385, 0, x_372);
+lean_ctor_set(x_385, 1, x_373);
+lean_ctor_set(x_385, 2, x_374);
+lean_ctor_set(x_385, 3, x_383);
+lean_ctor_set_uint8(x_385, sizeof(void*)*4, x_384);
+return x_385;
+}
+else
+{
+lean_object* x_386; lean_object* x_387; 
+x_386 = l_Std_RBNode_ins___rarg(x_1, x_375, x_3, x_4);
+x_387 = lean_ctor_get(x_386, 0);
+lean_inc(x_387);
+if (lean_obj_tag(x_387) == 0)
+{
+lean_object* x_388; 
+x_388 = lean_ctor_get(x_386, 3);
+lean_inc(x_388);
+if (lean_obj_tag(x_388) == 0)
+{
+lean_object* x_389; lean_object* x_390; lean_object* x_391; uint8_t x_392; lean_object* x_393; uint8_t x_394; lean_object* x_395; 
+x_389 = lean_ctor_get(x_386, 1);
+lean_inc(x_389);
+x_390 = lean_ctor_get(x_386, 2);
+lean_inc(x_390);
+if (lean_is_exclusive(x_386)) {
+ lean_ctor_release(x_386, 0);
+ lean_ctor_release(x_386, 1);
+ lean_ctor_release(x_386, 2);
+ lean_ctor_release(x_386, 3);
+ x_391 = x_386;
+} else {
+ lean_dec_ref(x_386);
+ x_391 = lean_box(0);
+}
+x_392 = 0;
+if (lean_is_scalar(x_391)) {
+ x_393 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_393 = x_391;
+}
+lean_ctor_set(x_393, 0, x_388);
+lean_ctor_set(x_393, 1, x_389);
+lean_ctor_set(x_393, 2, x_390);
+lean_ctor_set(x_393, 3, x_388);
+lean_ctor_set_uint8(x_393, sizeof(void*)*4, x_392);
+x_394 = 1;
+x_395 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_395, 0, x_372);
+lean_ctor_set(x_395, 1, x_373);
+lean_ctor_set(x_395, 2, x_374);
+lean_ctor_set(x_395, 3, x_393);
+lean_ctor_set_uint8(x_395, sizeof(void*)*4, x_394);
+return x_395;
+}
+else
+{
+uint8_t x_396; 
+x_396 = lean_ctor_get_uint8(x_388, sizeof(void*)*4);
+if (x_396 == 0)
+{
+lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; uint8_t x_405; lean_object* x_406; lean_object* x_407; uint8_t x_408; lean_object* x_409; 
+x_397 = lean_ctor_get(x_386, 1);
+lean_inc(x_397);
+x_398 = lean_ctor_get(x_386, 2);
+lean_inc(x_398);
+if (lean_is_exclusive(x_386)) {
+ lean_ctor_release(x_386, 0);
+ lean_ctor_release(x_386, 1);
+ lean_ctor_release(x_386, 2);
+ lean_ctor_release(x_386, 3);
+ x_399 = x_386;
+} else {
+ lean_dec_ref(x_386);
+ x_399 = lean_box(0);
+}
+x_400 = lean_ctor_get(x_388, 0);
+lean_inc(x_400);
+x_401 = lean_ctor_get(x_388, 1);
+lean_inc(x_401);
+x_402 = lean_ctor_get(x_388, 2);
+lean_inc(x_402);
+x_403 = lean_ctor_get(x_388, 3);
+lean_inc(x_403);
+if (lean_is_exclusive(x_388)) {
+ lean_ctor_release(x_388, 0);
+ lean_ctor_release(x_388, 1);
+ lean_ctor_release(x_388, 2);
+ lean_ctor_release(x_388, 3);
+ x_404 = x_388;
+} else {
+ lean_dec_ref(x_388);
+ x_404 = lean_box(0);
+}
+x_405 = 1;
+if (lean_is_scalar(x_404)) {
+ x_406 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_406 = x_404;
+}
+lean_ctor_set(x_406, 0, x_372);
+lean_ctor_set(x_406, 1, x_373);
+lean_ctor_set(x_406, 2, x_374);
+lean_ctor_set(x_406, 3, x_387);
+lean_ctor_set_uint8(x_406, sizeof(void*)*4, x_405);
+if (lean_is_scalar(x_399)) {
+ x_407 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_407 = x_399;
+}
+lean_ctor_set(x_407, 0, x_400);
+lean_ctor_set(x_407, 1, x_401);
+lean_ctor_set(x_407, 2, x_402);
+lean_ctor_set(x_407, 3, x_403);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_405);
+x_408 = 0;
+x_409 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_409, 0, x_406);
+lean_ctor_set(x_409, 1, x_397);
+lean_ctor_set(x_409, 2, x_398);
+lean_ctor_set(x_409, 3, x_407);
+lean_ctor_set_uint8(x_409, sizeof(void*)*4, x_408);
+return x_409;
+}
+else
+{
+lean_object* x_410; lean_object* x_411; lean_object* x_412; uint8_t x_413; lean_object* x_414; uint8_t x_415; lean_object* x_416; 
+x_410 = lean_ctor_get(x_386, 1);
+lean_inc(x_410);
+x_411 = lean_ctor_get(x_386, 2);
+lean_inc(x_411);
+if (lean_is_exclusive(x_386)) {
+ lean_ctor_release(x_386, 0);
+ lean_ctor_release(x_386, 1);
+ lean_ctor_release(x_386, 2);
+ lean_ctor_release(x_386, 3);
+ x_412 = x_386;
+} else {
+ lean_dec_ref(x_386);
+ x_412 = lean_box(0);
+}
+x_413 = 0;
+if (lean_is_scalar(x_412)) {
+ x_414 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_414 = x_412;
+}
+lean_ctor_set(x_414, 0, x_387);
+lean_ctor_set(x_414, 1, x_410);
+lean_ctor_set(x_414, 2, x_411);
+lean_ctor_set(x_414, 3, x_388);
+lean_ctor_set_uint8(x_414, sizeof(void*)*4, x_413);
+x_415 = 1;
+x_416 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_416, 0, x_372);
+lean_ctor_set(x_416, 1, x_373);
+lean_ctor_set(x_416, 2, x_374);
+lean_ctor_set(x_416, 3, x_414);
+lean_ctor_set_uint8(x_416, sizeof(void*)*4, x_415);
+return x_416;
+}
+}
+}
+else
+{
+uint8_t x_417; 
+x_417 = lean_ctor_get_uint8(x_387, sizeof(void*)*4);
+if (x_417 == 0)
+{
+lean_object* x_418; lean_object* x_419; lean_object* x_420; lean_object* x_421; lean_object* x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; uint8_t x_427; lean_object* x_428; lean_object* x_429; uint8_t x_430; lean_object* x_431; 
+x_418 = lean_ctor_get(x_386, 1);
+lean_inc(x_418);
+x_419 = lean_ctor_get(x_386, 2);
+lean_inc(x_419);
+x_420 = lean_ctor_get(x_386, 3);
+lean_inc(x_420);
+if (lean_is_exclusive(x_386)) {
+ lean_ctor_release(x_386, 0);
+ lean_ctor_release(x_386, 1);
+ lean_ctor_release(x_386, 2);
+ lean_ctor_release(x_386, 3);
+ x_421 = x_386;
+} else {
+ lean_dec_ref(x_386);
+ x_421 = lean_box(0);
+}
+x_422 = lean_ctor_get(x_387, 0);
+lean_inc(x_422);
+x_423 = lean_ctor_get(x_387, 1);
+lean_inc(x_423);
+x_424 = lean_ctor_get(x_387, 2);
+lean_inc(x_424);
+x_425 = lean_ctor_get(x_387, 3);
+lean_inc(x_425);
+if (lean_is_exclusive(x_387)) {
+ lean_ctor_release(x_387, 0);
+ lean_ctor_release(x_387, 1);
+ lean_ctor_release(x_387, 2);
+ lean_ctor_release(x_387, 3);
+ x_426 = x_387;
+} else {
+ lean_dec_ref(x_387);
+ x_426 = lean_box(0);
+}
+x_427 = 1;
+if (lean_is_scalar(x_426)) {
+ x_428 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_428 = x_426;
+}
+lean_ctor_set(x_428, 0, x_372);
+lean_ctor_set(x_428, 1, x_373);
+lean_ctor_set(x_428, 2, x_374);
+lean_ctor_set(x_428, 3, x_422);
+lean_ctor_set_uint8(x_428, sizeof(void*)*4, x_427);
+if (lean_is_scalar(x_421)) {
+ x_429 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_429 = x_421;
+}
+lean_ctor_set(x_429, 0, x_425);
+lean_ctor_set(x_429, 1, x_418);
+lean_ctor_set(x_429, 2, x_419);
+lean_ctor_set(x_429, 3, x_420);
+lean_ctor_set_uint8(x_429, sizeof(void*)*4, x_427);
+x_430 = 0;
+x_431 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_431, 0, x_428);
+lean_ctor_set(x_431, 1, x_423);
+lean_ctor_set(x_431, 2, x_424);
+lean_ctor_set(x_431, 3, x_429);
+lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_430);
+return x_431;
+}
+else
+{
+lean_object* x_432; 
+x_432 = lean_ctor_get(x_386, 3);
+lean_inc(x_432);
+if (lean_obj_tag(x_432) == 0)
+{
+lean_object* x_433; lean_object* x_434; lean_object* x_435; uint8_t x_436; lean_object* x_437; uint8_t x_438; lean_object* x_439; 
+x_433 = lean_ctor_get(x_386, 1);
+lean_inc(x_433);
+x_434 = lean_ctor_get(x_386, 2);
+lean_inc(x_434);
+if (lean_is_exclusive(x_386)) {
+ lean_ctor_release(x_386, 0);
+ lean_ctor_release(x_386, 1);
+ lean_ctor_release(x_386, 2);
+ lean_ctor_release(x_386, 3);
+ x_435 = x_386;
+} else {
+ lean_dec_ref(x_386);
+ x_435 = lean_box(0);
+}
+x_436 = 0;
+if (lean_is_scalar(x_435)) {
+ x_437 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_437 = x_435;
+}
+lean_ctor_set(x_437, 0, x_387);
+lean_ctor_set(x_437, 1, x_433);
+lean_ctor_set(x_437, 2, x_434);
+lean_ctor_set(x_437, 3, x_432);
+lean_ctor_set_uint8(x_437, sizeof(void*)*4, x_436);
+x_438 = 1;
+x_439 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_439, 0, x_372);
+lean_ctor_set(x_439, 1, x_373);
+lean_ctor_set(x_439, 2, x_374);
+lean_ctor_set(x_439, 3, x_437);
+lean_ctor_set_uint8(x_439, sizeof(void*)*4, x_438);
+return x_439;
+}
+else
+{
+uint8_t x_440; 
+x_440 = lean_ctor_get_uint8(x_432, sizeof(void*)*4);
+if (x_440 == 0)
+{
+lean_object* x_441; lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; uint8_t x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; uint8_t x_453; lean_object* x_454; 
+x_441 = lean_ctor_get(x_386, 1);
+lean_inc(x_441);
+x_442 = lean_ctor_get(x_386, 2);
+lean_inc(x_442);
+if (lean_is_exclusive(x_386)) {
+ lean_ctor_release(x_386, 0);
+ lean_ctor_release(x_386, 1);
+ lean_ctor_release(x_386, 2);
+ lean_ctor_release(x_386, 3);
+ x_443 = x_386;
+} else {
+ lean_dec_ref(x_386);
+ x_443 = lean_box(0);
+}
+x_444 = lean_ctor_get(x_432, 0);
+lean_inc(x_444);
+x_445 = lean_ctor_get(x_432, 1);
+lean_inc(x_445);
+x_446 = lean_ctor_get(x_432, 2);
+lean_inc(x_446);
+x_447 = lean_ctor_get(x_432, 3);
+lean_inc(x_447);
+if (lean_is_exclusive(x_432)) {
+ lean_ctor_release(x_432, 0);
+ lean_ctor_release(x_432, 1);
+ lean_ctor_release(x_432, 2);
+ lean_ctor_release(x_432, 3);
+ x_448 = x_432;
+} else {
+ lean_dec_ref(x_432);
+ x_448 = lean_box(0);
+}
+x_449 = 1;
+lean_inc(x_387);
+if (lean_is_scalar(x_448)) {
+ x_450 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_450 = x_448;
+}
+lean_ctor_set(x_450, 0, x_372);
+lean_ctor_set(x_450, 1, x_373);
+lean_ctor_set(x_450, 2, x_374);
+lean_ctor_set(x_450, 3, x_387);
+if (lean_is_exclusive(x_387)) {
+ lean_ctor_release(x_387, 0);
+ lean_ctor_release(x_387, 1);
+ lean_ctor_release(x_387, 2);
+ lean_ctor_release(x_387, 3);
+ x_451 = x_387;
+} else {
+ lean_dec_ref(x_387);
+ x_451 = lean_box(0);
+}
+lean_ctor_set_uint8(x_450, sizeof(void*)*4, x_449);
+if (lean_is_scalar(x_451)) {
+ x_452 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_452 = x_451;
+}
+lean_ctor_set(x_452, 0, x_444);
+lean_ctor_set(x_452, 1, x_445);
+lean_ctor_set(x_452, 2, x_446);
+lean_ctor_set(x_452, 3, x_447);
+lean_ctor_set_uint8(x_452, sizeof(void*)*4, x_449);
+x_453 = 0;
+if (lean_is_scalar(x_443)) {
+ x_454 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_454 = x_443;
+}
+lean_ctor_set(x_454, 0, x_450);
+lean_ctor_set(x_454, 1, x_441);
+lean_ctor_set(x_454, 2, x_442);
+lean_ctor_set(x_454, 3, x_452);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_453);
+return x_454;
+}
+else
+{
+lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; uint8_t x_464; lean_object* x_465; uint8_t x_466; lean_object* x_467; 
+x_455 = lean_ctor_get(x_386, 1);
+lean_inc(x_455);
+x_456 = lean_ctor_get(x_386, 2);
+lean_inc(x_456);
+if (lean_is_exclusive(x_386)) {
+ lean_ctor_release(x_386, 0);
+ lean_ctor_release(x_386, 1);
+ lean_ctor_release(x_386, 2);
+ lean_ctor_release(x_386, 3);
+ x_457 = x_386;
+} else {
+ lean_dec_ref(x_386);
+ x_457 = lean_box(0);
+}
+x_458 = lean_ctor_get(x_387, 0);
+lean_inc(x_458);
+x_459 = lean_ctor_get(x_387, 1);
+lean_inc(x_459);
+x_460 = lean_ctor_get(x_387, 2);
+lean_inc(x_460);
+x_461 = lean_ctor_get(x_387, 3);
+lean_inc(x_461);
+if (lean_is_exclusive(x_387)) {
+ lean_ctor_release(x_387, 0);
+ lean_ctor_release(x_387, 1);
+ lean_ctor_release(x_387, 2);
+ lean_ctor_release(x_387, 3);
+ x_462 = x_387;
+} else {
+ lean_dec_ref(x_387);
+ x_462 = lean_box(0);
+}
+if (lean_is_scalar(x_462)) {
+ x_463 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_463 = x_462;
+}
+lean_ctor_set(x_463, 0, x_458);
+lean_ctor_set(x_463, 1, x_459);
+lean_ctor_set(x_463, 2, x_460);
+lean_ctor_set(x_463, 3, x_461);
+lean_ctor_set_uint8(x_463, sizeof(void*)*4, x_440);
+x_464 = 0;
+if (lean_is_scalar(x_457)) {
+ x_465 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_465 = x_457;
+}
+lean_ctor_set(x_465, 0, x_463);
+lean_ctor_set(x_465, 1, x_455);
+lean_ctor_set(x_465, 2, x_456);
+lean_ctor_set(x_465, 3, x_432);
+lean_ctor_set_uint8(x_465, sizeof(void*)*4, x_464);
+x_466 = 1;
+x_467 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_467, 0, x_372);
+lean_ctor_set(x_467, 1, x_373);
+lean_ctor_set(x_467, 2, x_374);
+lean_ctor_set(x_467, 3, x_465);
+lean_ctor_set_uint8(x_467, sizeof(void*)*4, x_466);
+return x_467;
+}
+}
+}
+}
+}
+}
+}
+else
+{
+uint8_t x_468; 
+x_468 = l_Std_RBNode_isRed___rarg(x_372);
+if (x_468 == 0)
+{
+lean_object* x_469; uint8_t x_470; lean_object* x_471; 
+x_469 = l_Std_RBNode_ins___rarg(x_1, x_372, x_3, x_4);
+x_470 = 1;
+x_471 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_471, 0, x_469);
+lean_ctor_set(x_471, 1, x_373);
+lean_ctor_set(x_471, 2, x_374);
+lean_ctor_set(x_471, 3, x_375);
+lean_ctor_set_uint8(x_471, sizeof(void*)*4, x_470);
+return x_471;
+}
+else
+{
+lean_object* x_472; lean_object* x_473; 
+x_472 = l_Std_RBNode_ins___rarg(x_1, x_372, x_3, x_4);
+x_473 = lean_ctor_get(x_472, 0);
+lean_inc(x_473);
+if (lean_obj_tag(x_473) == 0)
+{
+lean_object* x_474; 
+x_474 = lean_ctor_get(x_472, 3);
+lean_inc(x_474);
+if (lean_obj_tag(x_474) == 0)
+{
+lean_object* x_475; lean_object* x_476; lean_object* x_477; uint8_t x_478; lean_object* x_479; uint8_t x_480; lean_object* x_481; 
+x_475 = lean_ctor_get(x_472, 1);
+lean_inc(x_475);
+x_476 = lean_ctor_get(x_472, 2);
+lean_inc(x_476);
+if (lean_is_exclusive(x_472)) {
+ lean_ctor_release(x_472, 0);
+ lean_ctor_release(x_472, 1);
+ lean_ctor_release(x_472, 2);
+ lean_ctor_release(x_472, 3);
+ x_477 = x_472;
+} else {
+ lean_dec_ref(x_472);
+ x_477 = lean_box(0);
+}
+x_478 = 0;
+if (lean_is_scalar(x_477)) {
+ x_479 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_479 = x_477;
+}
+lean_ctor_set(x_479, 0, x_474);
+lean_ctor_set(x_479, 1, x_475);
+lean_ctor_set(x_479, 2, x_476);
+lean_ctor_set(x_479, 3, x_474);
+lean_ctor_set_uint8(x_479, sizeof(void*)*4, x_478);
+x_480 = 1;
+x_481 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_481, 0, x_479);
+lean_ctor_set(x_481, 1, x_373);
+lean_ctor_set(x_481, 2, x_374);
+lean_ctor_set(x_481, 3, x_375);
+lean_ctor_set_uint8(x_481, sizeof(void*)*4, x_480);
+return x_481;
+}
+else
+{
+uint8_t x_482; 
+x_482 = lean_ctor_get_uint8(x_474, sizeof(void*)*4);
+if (x_482 == 0)
+{
+lean_object* x_483; lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; lean_object* x_489; lean_object* x_490; uint8_t x_491; lean_object* x_492; lean_object* x_493; uint8_t x_494; lean_object* x_495; 
+x_483 = lean_ctor_get(x_472, 1);
+lean_inc(x_483);
+x_484 = lean_ctor_get(x_472, 2);
+lean_inc(x_484);
+if (lean_is_exclusive(x_472)) {
+ lean_ctor_release(x_472, 0);
+ lean_ctor_release(x_472, 1);
+ lean_ctor_release(x_472, 2);
+ lean_ctor_release(x_472, 3);
+ x_485 = x_472;
+} else {
+ lean_dec_ref(x_472);
+ x_485 = lean_box(0);
+}
+x_486 = lean_ctor_get(x_474, 0);
+lean_inc(x_486);
+x_487 = lean_ctor_get(x_474, 1);
+lean_inc(x_487);
+x_488 = lean_ctor_get(x_474, 2);
+lean_inc(x_488);
+x_489 = lean_ctor_get(x_474, 3);
+lean_inc(x_489);
+if (lean_is_exclusive(x_474)) {
+ lean_ctor_release(x_474, 0);
+ lean_ctor_release(x_474, 1);
+ lean_ctor_release(x_474, 2);
+ lean_ctor_release(x_474, 3);
+ x_490 = x_474;
+} else {
+ lean_dec_ref(x_474);
+ x_490 = lean_box(0);
+}
+x_491 = 1;
+if (lean_is_scalar(x_490)) {
+ x_492 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_492 = x_490;
+}
+lean_ctor_set(x_492, 0, x_473);
+lean_ctor_set(x_492, 1, x_483);
+lean_ctor_set(x_492, 2, x_484);
+lean_ctor_set(x_492, 3, x_486);
+lean_ctor_set_uint8(x_492, sizeof(void*)*4, x_491);
+if (lean_is_scalar(x_485)) {
+ x_493 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_493 = x_485;
+}
+lean_ctor_set(x_493, 0, x_489);
+lean_ctor_set(x_493, 1, x_373);
+lean_ctor_set(x_493, 2, x_374);
+lean_ctor_set(x_493, 3, x_375);
+lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_491);
+x_494 = 0;
+x_495 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_495, 0, x_492);
+lean_ctor_set(x_495, 1, x_487);
+lean_ctor_set(x_495, 2, x_488);
+lean_ctor_set(x_495, 3, x_493);
+lean_ctor_set_uint8(x_495, sizeof(void*)*4, x_494);
+return x_495;
+}
+else
+{
+lean_object* x_496; lean_object* x_497; lean_object* x_498; uint8_t x_499; lean_object* x_500; uint8_t x_501; lean_object* x_502; 
+x_496 = lean_ctor_get(x_472, 1);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_472, 2);
+lean_inc(x_497);
+if (lean_is_exclusive(x_472)) {
+ lean_ctor_release(x_472, 0);
+ lean_ctor_release(x_472, 1);
+ lean_ctor_release(x_472, 2);
+ lean_ctor_release(x_472, 3);
+ x_498 = x_472;
+} else {
+ lean_dec_ref(x_472);
+ x_498 = lean_box(0);
+}
+x_499 = 0;
+if (lean_is_scalar(x_498)) {
+ x_500 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_500 = x_498;
+}
+lean_ctor_set(x_500, 0, x_473);
+lean_ctor_set(x_500, 1, x_496);
+lean_ctor_set(x_500, 2, x_497);
+lean_ctor_set(x_500, 3, x_474);
+lean_ctor_set_uint8(x_500, sizeof(void*)*4, x_499);
+x_501 = 1;
+x_502 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_502, 0, x_500);
+lean_ctor_set(x_502, 1, x_373);
+lean_ctor_set(x_502, 2, x_374);
+lean_ctor_set(x_502, 3, x_375);
+lean_ctor_set_uint8(x_502, sizeof(void*)*4, x_501);
+return x_502;
+}
+}
+}
+else
+{
+uint8_t x_503; 
+x_503 = lean_ctor_get_uint8(x_473, sizeof(void*)*4);
+if (x_503 == 0)
+{
+lean_object* x_504; lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; uint8_t x_513; lean_object* x_514; lean_object* x_515; uint8_t x_516; lean_object* x_517; 
+x_504 = lean_ctor_get(x_472, 1);
+lean_inc(x_504);
+x_505 = lean_ctor_get(x_472, 2);
+lean_inc(x_505);
+x_506 = lean_ctor_get(x_472, 3);
+lean_inc(x_506);
+if (lean_is_exclusive(x_472)) {
+ lean_ctor_release(x_472, 0);
+ lean_ctor_release(x_472, 1);
+ lean_ctor_release(x_472, 2);
+ lean_ctor_release(x_472, 3);
+ x_507 = x_472;
+} else {
+ lean_dec_ref(x_472);
+ x_507 = lean_box(0);
+}
+x_508 = lean_ctor_get(x_473, 0);
+lean_inc(x_508);
+x_509 = lean_ctor_get(x_473, 1);
+lean_inc(x_509);
+x_510 = lean_ctor_get(x_473, 2);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_473, 3);
+lean_inc(x_511);
+if (lean_is_exclusive(x_473)) {
+ lean_ctor_release(x_473, 0);
+ lean_ctor_release(x_473, 1);
+ lean_ctor_release(x_473, 2);
+ lean_ctor_release(x_473, 3);
+ x_512 = x_473;
+} else {
+ lean_dec_ref(x_473);
+ x_512 = lean_box(0);
+}
+x_513 = 1;
+if (lean_is_scalar(x_512)) {
+ x_514 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_514 = x_512;
+}
+lean_ctor_set(x_514, 0, x_508);
+lean_ctor_set(x_514, 1, x_509);
+lean_ctor_set(x_514, 2, x_510);
+lean_ctor_set(x_514, 3, x_511);
+lean_ctor_set_uint8(x_514, sizeof(void*)*4, x_513);
+if (lean_is_scalar(x_507)) {
+ x_515 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_515 = x_507;
+}
+lean_ctor_set(x_515, 0, x_506);
+lean_ctor_set(x_515, 1, x_373);
+lean_ctor_set(x_515, 2, x_374);
+lean_ctor_set(x_515, 3, x_375);
+lean_ctor_set_uint8(x_515, sizeof(void*)*4, x_513);
+x_516 = 0;
+x_517 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_517, 0, x_514);
+lean_ctor_set(x_517, 1, x_504);
+lean_ctor_set(x_517, 2, x_505);
+lean_ctor_set(x_517, 3, x_515);
+lean_ctor_set_uint8(x_517, sizeof(void*)*4, x_516);
+return x_517;
+}
+else
+{
+lean_object* x_518; 
+x_518 = lean_ctor_get(x_472, 3);
+lean_inc(x_518);
+if (lean_obj_tag(x_518) == 0)
+{
+lean_object* x_519; lean_object* x_520; lean_object* x_521; uint8_t x_522; lean_object* x_523; uint8_t x_524; lean_object* x_525; 
+x_519 = lean_ctor_get(x_472, 1);
+lean_inc(x_519);
+x_520 = lean_ctor_get(x_472, 2);
+lean_inc(x_520);
+if (lean_is_exclusive(x_472)) {
+ lean_ctor_release(x_472, 0);
+ lean_ctor_release(x_472, 1);
+ lean_ctor_release(x_472, 2);
+ lean_ctor_release(x_472, 3);
+ x_521 = x_472;
+} else {
+ lean_dec_ref(x_472);
+ x_521 = lean_box(0);
+}
+x_522 = 0;
+if (lean_is_scalar(x_521)) {
+ x_523 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_523 = x_521;
+}
+lean_ctor_set(x_523, 0, x_473);
+lean_ctor_set(x_523, 1, x_519);
+lean_ctor_set(x_523, 2, x_520);
+lean_ctor_set(x_523, 3, x_518);
+lean_ctor_set_uint8(x_523, sizeof(void*)*4, x_522);
+x_524 = 1;
+x_525 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_525, 0, x_523);
+lean_ctor_set(x_525, 1, x_373);
+lean_ctor_set(x_525, 2, x_374);
+lean_ctor_set(x_525, 3, x_375);
+lean_ctor_set_uint8(x_525, sizeof(void*)*4, x_524);
+return x_525;
+}
+else
+{
+uint8_t x_526; 
+x_526 = lean_ctor_get_uint8(x_518, sizeof(void*)*4);
+if (x_526 == 0)
+{
+lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; uint8_t x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; uint8_t x_539; lean_object* x_540; 
+x_527 = lean_ctor_get(x_472, 1);
+lean_inc(x_527);
+x_528 = lean_ctor_get(x_472, 2);
+lean_inc(x_528);
+if (lean_is_exclusive(x_472)) {
+ lean_ctor_release(x_472, 0);
+ lean_ctor_release(x_472, 1);
+ lean_ctor_release(x_472, 2);
+ lean_ctor_release(x_472, 3);
+ x_529 = x_472;
+} else {
+ lean_dec_ref(x_472);
+ x_529 = lean_box(0);
+}
+x_530 = lean_ctor_get(x_518, 0);
+lean_inc(x_530);
+x_531 = lean_ctor_get(x_518, 1);
+lean_inc(x_531);
+x_532 = lean_ctor_get(x_518, 2);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_518, 3);
+lean_inc(x_533);
+if (lean_is_exclusive(x_518)) {
+ lean_ctor_release(x_518, 0);
+ lean_ctor_release(x_518, 1);
+ lean_ctor_release(x_518, 2);
+ lean_ctor_release(x_518, 3);
+ x_534 = x_518;
+} else {
+ lean_dec_ref(x_518);
+ x_534 = lean_box(0);
+}
+x_535 = 1;
+lean_inc(x_473);
+if (lean_is_scalar(x_534)) {
+ x_536 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_536 = x_534;
+}
+lean_ctor_set(x_536, 0, x_473);
+lean_ctor_set(x_536, 1, x_527);
+lean_ctor_set(x_536, 2, x_528);
+lean_ctor_set(x_536, 3, x_530);
+if (lean_is_exclusive(x_473)) {
+ lean_ctor_release(x_473, 0);
+ lean_ctor_release(x_473, 1);
+ lean_ctor_release(x_473, 2);
+ lean_ctor_release(x_473, 3);
+ x_537 = x_473;
+} else {
+ lean_dec_ref(x_473);
+ x_537 = lean_box(0);
+}
+lean_ctor_set_uint8(x_536, sizeof(void*)*4, x_535);
+if (lean_is_scalar(x_537)) {
+ x_538 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_538 = x_537;
+}
+lean_ctor_set(x_538, 0, x_533);
+lean_ctor_set(x_538, 1, x_373);
+lean_ctor_set(x_538, 2, x_374);
+lean_ctor_set(x_538, 3, x_375);
+lean_ctor_set_uint8(x_538, sizeof(void*)*4, x_535);
+x_539 = 0;
+if (lean_is_scalar(x_529)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_529;
+}
+lean_ctor_set(x_540, 0, x_536);
+lean_ctor_set(x_540, 1, x_531);
+lean_ctor_set(x_540, 2, x_532);
+lean_ctor_set(x_540, 3, x_538);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_539);
+return x_540;
+}
+else
+{
+lean_object* x_541; lean_object* x_542; lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; uint8_t x_550; lean_object* x_551; uint8_t x_552; lean_object* x_553; 
+x_541 = lean_ctor_get(x_472, 1);
+lean_inc(x_541);
+x_542 = lean_ctor_get(x_472, 2);
+lean_inc(x_542);
+if (lean_is_exclusive(x_472)) {
+ lean_ctor_release(x_472, 0);
+ lean_ctor_release(x_472, 1);
+ lean_ctor_release(x_472, 2);
+ lean_ctor_release(x_472, 3);
+ x_543 = x_472;
+} else {
+ lean_dec_ref(x_472);
+ x_543 = lean_box(0);
+}
+x_544 = lean_ctor_get(x_473, 0);
+lean_inc(x_544);
+x_545 = lean_ctor_get(x_473, 1);
+lean_inc(x_545);
+x_546 = lean_ctor_get(x_473, 2);
+lean_inc(x_546);
+x_547 = lean_ctor_get(x_473, 3);
+lean_inc(x_547);
+if (lean_is_exclusive(x_473)) {
+ lean_ctor_release(x_473, 0);
+ lean_ctor_release(x_473, 1);
+ lean_ctor_release(x_473, 2);
+ lean_ctor_release(x_473, 3);
+ x_548 = x_473;
+} else {
+ lean_dec_ref(x_473);
+ x_548 = lean_box(0);
+}
+if (lean_is_scalar(x_548)) {
+ x_549 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_549 = x_548;
+}
+lean_ctor_set(x_549, 0, x_544);
+lean_ctor_set(x_549, 1, x_545);
+lean_ctor_set(x_549, 2, x_546);
+lean_ctor_set(x_549, 3, x_547);
+lean_ctor_set_uint8(x_549, sizeof(void*)*4, x_526);
+x_550 = 0;
+if (lean_is_scalar(x_543)) {
+ x_551 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_551 = x_543;
+}
+lean_ctor_set(x_551, 0, x_549);
+lean_ctor_set(x_551, 1, x_541);
+lean_ctor_set(x_551, 2, x_542);
+lean_ctor_set(x_551, 3, x_518);
+lean_ctor_set_uint8(x_551, sizeof(void*)*4, x_550);
+x_552 = 1;
+x_553 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_553, 0, x_551);
+lean_ctor_set(x_553, 1, x_373);
+lean_ctor_set(x_553, 2, x_374);
+lean_ctor_set(x_553, 3, x_375);
+lean_ctor_set_uint8(x_553, sizeof(void*)*4, x_552);
+return x_553;
+}
+}
+}
+}
+}
+}
+}
+}
+}
 }
 }
 lean_object* l_Std_RBNode_ins(lean_object* x_1, lean_object* x_2) {
@@ -4865,6 +5813,44 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_ins___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_setBlack_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+uint8_t 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_dec(x_3);
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 2);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 3);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_box(x_5);
+x_11 = lean_apply_5(x_2, x_10, x_6, x_7, x_8, x_9);
+return x_11;
+}
+}
+}
+lean_object* l_Std_RBNode_setBlack_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_setBlack_match__1___rarg), 3, 0);
+return x_4;
+}
+}
 lean_object* l_Std_RBNode_setBlack___rarg(lean_object* x_1) {
 _start:
 {
@@ -4923,13 +5909,13 @@ x_5 = l_Std_RBNode_isRed___rarg(x_2);
 if (x_5 == 0)
 {
 lean_object* x_6; 
-x_6 = l_Std_RBNode_ins___main___rarg(x_1, x_2, x_3, x_4);
+x_6 = l_Std_RBNode_ins___rarg(x_1, x_2, x_3, x_4);
 return x_6;
 }
 else
 {
 lean_object* x_7; lean_object* x_8; 
-x_7 = l_Std_RBNode_ins___main___rarg(x_1, x_2, x_3, x_4);
+x_7 = l_Std_RBNode_ins___rarg(x_1, x_2, x_3, x_4);
 x_8 = l_Std_RBNode_setBlack___rarg(x_7);
 return x_8;
 }
@@ -4943,6 +5929,639 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_insert___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_balance_u2083_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_5 = lean_apply_1(x_4, x_1);
+return x_5;
+}
+else
+{
+uint8_t x_6; 
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_6 == 0)
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; 
+lean_dec(x_3);
+x_8 = lean_ctor_get(x_1, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
+{
+uint8_t x_9; 
+lean_dec(x_2);
+x_9 = !lean_is_exclusive(x_1);
+if (x_9 == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_10 = lean_ctor_get(x_1, 3);
+lean_dec(x_10);
+x_11 = lean_ctor_get(x_1, 0);
+lean_dec(x_11);
+lean_ctor_set(x_1, 0, x_8);
+x_12 = lean_apply_1(x_4, x_1);
+return x_12;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_13 = lean_ctor_get(x_1, 1);
+x_14 = lean_ctor_get(x_1, 2);
+lean_inc(x_14);
+lean_inc(x_13);
+lean_dec(x_1);
+x_15 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_15, 0, x_8);
+lean_ctor_set(x_15, 1, x_13);
+lean_ctor_set(x_15, 2, x_14);
+lean_ctor_set(x_15, 3, x_8);
+lean_ctor_set_uint8(x_15, sizeof(void*)*4, x_6);
+x_16 = lean_apply_1(x_4, x_15);
+return x_16;
+}
+}
+else
+{
+uint8_t x_17; 
+x_17 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
+if (x_17 == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_4);
+x_18 = lean_ctor_get(x_1, 1);
+lean_inc(x_18);
+x_19 = lean_ctor_get(x_1, 2);
+lean_inc(x_19);
+lean_dec(x_1);
+x_20 = lean_ctor_get(x_8, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_8, 1);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_8, 2);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_8, 3);
+lean_inc(x_23);
+lean_dec(x_8);
+x_24 = lean_apply_7(x_2, x_7, x_18, x_19, x_20, x_21, x_22, x_23);
+return x_24;
+}
+else
+{
+lean_object* x_25; 
+lean_dec(x_8);
+lean_dec(x_2);
+x_25 = lean_apply_1(x_4, x_1);
+return x_25;
+}
+}
+}
+else
+{
+uint8_t x_26; 
+x_26 = lean_ctor_get_uint8(x_7, sizeof(void*)*4);
+if (x_26 == 0)
+{
+lean_object* x_27; 
+lean_dec(x_4);
+x_27 = lean_ctor_get(x_1, 3);
+lean_inc(x_27);
+if (lean_obj_tag(x_27) == 0)
+{
+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_dec(x_2);
+x_28 = lean_ctor_get(x_1, 1);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_1, 2);
+lean_inc(x_29);
+lean_dec(x_1);
+x_30 = lean_ctor_get(x_7, 0);
+lean_inc(x_30);
+x_31 = lean_ctor_get(x_7, 1);
+lean_inc(x_31);
+x_32 = lean_ctor_get(x_7, 2);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_7, 3);
+lean_inc(x_33);
+lean_dec(x_7);
+x_34 = lean_apply_7(x_3, x_30, x_31, x_32, x_33, x_28, x_29, x_27);
+return x_34;
+}
+else
+{
+uint8_t x_35; 
+x_35 = lean_ctor_get_uint8(x_27, sizeof(void*)*4);
+if (x_35 == 0)
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; 
+lean_dec(x_3);
+x_36 = lean_ctor_get(x_1, 1);
+lean_inc(x_36);
+x_37 = lean_ctor_get(x_1, 2);
+lean_inc(x_37);
+lean_dec(x_1);
+x_38 = lean_ctor_get(x_7, 0);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_7, 1);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_7, 2);
+lean_inc(x_40);
+x_41 = lean_ctor_get(x_7, 3);
+lean_inc(x_41);
+lean_dec(x_7);
+x_42 = !lean_is_exclusive(x_27);
+if (x_42 == 0)
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_43 = lean_ctor_get(x_27, 0);
+x_44 = lean_ctor_get(x_27, 1);
+x_45 = lean_ctor_get(x_27, 2);
+x_46 = lean_ctor_get(x_27, 3);
+lean_ctor_set(x_27, 3, x_41);
+lean_ctor_set(x_27, 2, x_40);
+lean_ctor_set(x_27, 1, x_39);
+lean_ctor_set(x_27, 0, x_38);
+x_47 = lean_apply_7(x_2, x_27, x_36, x_37, x_43, x_44, x_45, x_46);
+return x_47;
+}
+else
+{
+lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; 
+x_48 = lean_ctor_get(x_27, 0);
+x_49 = lean_ctor_get(x_27, 1);
+x_50 = lean_ctor_get(x_27, 2);
+x_51 = lean_ctor_get(x_27, 3);
+lean_inc(x_51);
+lean_inc(x_50);
+lean_inc(x_49);
+lean_inc(x_48);
+lean_dec(x_27);
+x_52 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_52, 0, x_38);
+lean_ctor_set(x_52, 1, x_39);
+lean_ctor_set(x_52, 2, x_40);
+lean_ctor_set(x_52, 3, x_41);
+lean_ctor_set_uint8(x_52, sizeof(void*)*4, x_35);
+x_53 = lean_apply_7(x_2, x_52, x_36, x_37, x_48, x_49, x_50, x_51);
+return x_53;
+}
+}
+else
+{
+lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+lean_dec(x_2);
+x_54 = lean_ctor_get(x_1, 1);
+lean_inc(x_54);
+x_55 = lean_ctor_get(x_1, 2);
+lean_inc(x_55);
+lean_dec(x_1);
+x_56 = lean_ctor_get(x_7, 0);
+lean_inc(x_56);
+x_57 = lean_ctor_get(x_7, 1);
+lean_inc(x_57);
+x_58 = lean_ctor_get(x_7, 2);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_7, 3);
+lean_inc(x_59);
+lean_dec(x_7);
+x_60 = lean_apply_7(x_3, x_56, x_57, x_58, x_59, x_54, x_55, x_27);
+return x_60;
+}
+}
+}
+else
+{
+lean_object* x_61; 
+lean_dec(x_3);
+x_61 = lean_ctor_get(x_1, 3);
+lean_inc(x_61);
+if (lean_obj_tag(x_61) == 0)
+{
+lean_object* x_62; 
+lean_dec(x_7);
+lean_dec(x_2);
+x_62 = lean_apply_1(x_4, x_1);
+return x_62;
+}
+else
+{
+uint8_t x_63; 
+x_63 = lean_ctor_get_uint8(x_61, sizeof(void*)*4);
+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_dec(x_4);
+x_64 = lean_ctor_get(x_1, 1);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_1, 2);
+lean_inc(x_65);
+lean_dec(x_1);
+x_66 = lean_ctor_get(x_61, 0);
+lean_inc(x_66);
+x_67 = lean_ctor_get(x_61, 1);
+lean_inc(x_67);
+x_68 = lean_ctor_get(x_61, 2);
+lean_inc(x_68);
+x_69 = lean_ctor_get(x_61, 3);
+lean_inc(x_69);
+lean_dec(x_61);
+x_70 = lean_apply_7(x_2, x_7, x_64, x_65, x_66, x_67, x_68, x_69);
+return x_70;
+}
+else
+{
+uint8_t x_71; 
+lean_dec(x_2);
+x_71 = !lean_is_exclusive(x_1);
+if (x_71 == 0)
+{
+lean_object* x_72; lean_object* x_73; uint8_t x_74; 
+x_72 = lean_ctor_get(x_1, 3);
+lean_dec(x_72);
+x_73 = lean_ctor_get(x_1, 0);
+lean_dec(x_73);
+x_74 = !lean_is_exclusive(x_7);
+if (x_74 == 0)
+{
+lean_object* x_75; 
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_63);
+x_75 = lean_apply_1(x_4, x_1);
+return x_75;
+}
+else
+{
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; 
+x_76 = lean_ctor_get(x_7, 0);
+x_77 = lean_ctor_get(x_7, 1);
+x_78 = lean_ctor_get(x_7, 2);
+x_79 = lean_ctor_get(x_7, 3);
+lean_inc(x_79);
+lean_inc(x_78);
+lean_inc(x_77);
+lean_inc(x_76);
+lean_dec(x_7);
+x_80 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_80, 0, x_76);
+lean_ctor_set(x_80, 1, x_77);
+lean_ctor_set(x_80, 2, x_78);
+lean_ctor_set(x_80, 3, x_79);
+lean_ctor_set_uint8(x_80, sizeof(void*)*4, x_63);
+lean_ctor_set(x_1, 0, x_80);
+x_81 = lean_apply_1(x_4, x_1);
+return x_81;
+}
+}
+else
+{
+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; 
+x_82 = lean_ctor_get(x_1, 1);
+x_83 = lean_ctor_get(x_1, 2);
+lean_inc(x_83);
+lean_inc(x_82);
+lean_dec(x_1);
+x_84 = lean_ctor_get(x_7, 0);
+lean_inc(x_84);
+x_85 = lean_ctor_get(x_7, 1);
+lean_inc(x_85);
+x_86 = lean_ctor_get(x_7, 2);
+lean_inc(x_86);
+x_87 = lean_ctor_get(x_7, 3);
+lean_inc(x_87);
+if (lean_is_exclusive(x_7)) {
+ lean_ctor_release(x_7, 0);
+ lean_ctor_release(x_7, 1);
+ lean_ctor_release(x_7, 2);
+ lean_ctor_release(x_7, 3);
+ x_88 = x_7;
+} else {
+ lean_dec_ref(x_7);
+ x_88 = lean_box(0);
+}
+if (lean_is_scalar(x_88)) {
+ x_89 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_89 = x_88;
+}
+lean_ctor_set(x_89, 0, x_84);
+lean_ctor_set(x_89, 1, x_85);
+lean_ctor_set(x_89, 2, x_86);
+lean_ctor_set(x_89, 3, x_87);
+lean_ctor_set_uint8(x_89, sizeof(void*)*4, x_63);
+x_90 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_90, 0, x_89);
+lean_ctor_set(x_90, 1, x_82);
+lean_ctor_set(x_90, 2, x_83);
+lean_ctor_set(x_90, 3, x_61);
+lean_ctor_set_uint8(x_90, sizeof(void*)*4, x_6);
+x_91 = lean_apply_1(x_4, x_90);
+return x_91;
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_92; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_92 = lean_apply_1(x_4, x_1);
+return x_92;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_balance_u2083_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_balance_u2083_match__1___rarg), 4, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_balance_u2083_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_5 = lean_apply_1(x_4, x_1);
+return x_5;
+}
+else
+{
+uint8_t x_6; 
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_6 == 0)
+{
+lean_object* x_7; 
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; 
+lean_dec(x_2);
+x_8 = lean_ctor_get(x_1, 3);
+lean_inc(x_8);
+if (lean_obj_tag(x_8) == 0)
+{
+uint8_t x_9; 
+lean_dec(x_3);
+x_9 = !lean_is_exclusive(x_1);
+if (x_9 == 0)
+{
+lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+x_10 = lean_ctor_get(x_1, 3);
+lean_dec(x_10);
+x_11 = lean_ctor_get(x_1, 0);
+lean_dec(x_11);
+lean_ctor_set(x_1, 0, x_8);
+x_12 = lean_apply_1(x_4, x_1);
+return x_12;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
+x_13 = lean_ctor_get(x_1, 1);
+x_14 = lean_ctor_get(x_1, 2);
+lean_inc(x_14);
+lean_inc(x_13);
+lean_dec(x_1);
+x_15 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_15, 0, x_8);
+lean_ctor_set(x_15, 1, x_13);
+lean_ctor_set(x_15, 2, x_14);
+lean_ctor_set(x_15, 3, x_8);
+lean_ctor_set_uint8(x_15, sizeof(void*)*4, x_6);
+x_16 = lean_apply_1(x_4, x_15);
+return x_16;
+}
+}
+else
+{
+uint8_t x_17; 
+x_17 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
+if (x_17 == 0)
+{
+lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; 
+lean_dec(x_4);
+x_18 = lean_ctor_get(x_1, 1);
+lean_inc(x_18);
+x_19 = lean_ctor_get(x_1, 2);
+lean_inc(x_19);
+lean_dec(x_1);
+x_20 = lean_ctor_get(x_8, 0);
+lean_inc(x_20);
+x_21 = lean_ctor_get(x_8, 1);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_8, 2);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_8, 3);
+lean_inc(x_23);
+lean_dec(x_8);
+x_24 = lean_apply_7(x_3, x_7, x_18, x_19, x_20, x_21, x_22, x_23);
+return x_24;
+}
+else
+{
+lean_object* x_25; 
+lean_dec(x_8);
+lean_dec(x_3);
+x_25 = lean_apply_1(x_4, x_1);
+return x_25;
+}
+}
+}
+else
+{
+uint8_t x_26; 
+x_26 = lean_ctor_get_uint8(x_7, sizeof(void*)*4);
+if (x_26 == 0)
+{
+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_dec(x_4);
+lean_dec(x_3);
+x_27 = lean_ctor_get(x_1, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_1, 2);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_1, 3);
+lean_inc(x_29);
+lean_dec(x_1);
+x_30 = lean_ctor_get(x_7, 0);
+lean_inc(x_30);
+x_31 = lean_ctor_get(x_7, 1);
+lean_inc(x_31);
+x_32 = lean_ctor_get(x_7, 2);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_7, 3);
+lean_inc(x_33);
+lean_dec(x_7);
+x_34 = lean_apply_7(x_2, x_30, x_31, x_32, x_33, x_27, x_28, x_29);
+return x_34;
+}
+else
+{
+lean_object* x_35; 
+lean_dec(x_2);
+x_35 = lean_ctor_get(x_1, 3);
+lean_inc(x_35);
+if (lean_obj_tag(x_35) == 0)
+{
+lean_object* x_36; 
+lean_dec(x_7);
+lean_dec(x_3);
+x_36 = lean_apply_1(x_4, x_1);
+return x_36;
+}
+else
+{
+uint8_t x_37; 
+x_37 = lean_ctor_get_uint8(x_35, sizeof(void*)*4);
+if (x_37 == 0)
+{
+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_dec(x_4);
+x_38 = lean_ctor_get(x_1, 1);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_1, 2);
+lean_inc(x_39);
+lean_dec(x_1);
+x_40 = lean_ctor_get(x_35, 0);
+lean_inc(x_40);
+x_41 = lean_ctor_get(x_35, 1);
+lean_inc(x_41);
+x_42 = lean_ctor_get(x_35, 2);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_35, 3);
+lean_inc(x_43);
+lean_dec(x_35);
+x_44 = lean_apply_7(x_3, x_7, x_38, x_39, x_40, x_41, x_42, x_43);
+return x_44;
+}
+else
+{
+uint8_t x_45; 
+lean_dec(x_3);
+x_45 = !lean_is_exclusive(x_1);
+if (x_45 == 0)
+{
+lean_object* x_46; lean_object* x_47; uint8_t x_48; 
+x_46 = lean_ctor_get(x_1, 3);
+lean_dec(x_46);
+x_47 = lean_ctor_get(x_1, 0);
+lean_dec(x_47);
+x_48 = !lean_is_exclusive(x_7);
+if (x_48 == 0)
+{
+lean_object* x_49; 
+lean_ctor_set_uint8(x_7, sizeof(void*)*4, x_37);
+x_49 = lean_apply_1(x_4, x_1);
+return x_49;
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
+x_50 = lean_ctor_get(x_7, 0);
+x_51 = lean_ctor_get(x_7, 1);
+x_52 = lean_ctor_get(x_7, 2);
+x_53 = lean_ctor_get(x_7, 3);
+lean_inc(x_53);
+lean_inc(x_52);
+lean_inc(x_51);
+lean_inc(x_50);
+lean_dec(x_7);
+x_54 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_54, 0, x_50);
+lean_ctor_set(x_54, 1, x_51);
+lean_ctor_set(x_54, 2, x_52);
+lean_ctor_set(x_54, 3, x_53);
+lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_37);
+lean_ctor_set(x_1, 0, x_54);
+x_55 = lean_apply_1(x_4, x_1);
+return x_55;
+}
+}
+else
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+x_56 = lean_ctor_get(x_1, 1);
+x_57 = lean_ctor_get(x_1, 2);
+lean_inc(x_57);
+lean_inc(x_56);
+lean_dec(x_1);
+x_58 = lean_ctor_get(x_7, 0);
+lean_inc(x_58);
+x_59 = lean_ctor_get(x_7, 1);
+lean_inc(x_59);
+x_60 = lean_ctor_get(x_7, 2);
+lean_inc(x_60);
+x_61 = lean_ctor_get(x_7, 3);
+lean_inc(x_61);
+if (lean_is_exclusive(x_7)) {
+ lean_ctor_release(x_7, 0);
+ lean_ctor_release(x_7, 1);
+ lean_ctor_release(x_7, 2);
+ lean_ctor_release(x_7, 3);
+ x_62 = x_7;
+} else {
+ lean_dec_ref(x_7);
+ x_62 = lean_box(0);
+}
+if (lean_is_scalar(x_62)) {
+ x_63 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_63 = x_62;
+}
+lean_ctor_set(x_63, 0, x_58);
+lean_ctor_set(x_63, 1, x_59);
+lean_ctor_set(x_63, 2, x_60);
+lean_ctor_set(x_63, 3, x_61);
+lean_ctor_set_uint8(x_63, sizeof(void*)*4, x_37);
+x_64 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_64, 0, x_63);
+lean_ctor_set(x_64, 1, x_56);
+lean_ctor_set(x_64, 2, x_57);
+lean_ctor_set(x_64, 3, x_35);
+lean_ctor_set_uint8(x_64, sizeof(void*)*4, x_6);
+x_65 = lean_apply_1(x_4, x_64);
+return x_65;
+}
+}
+}
+}
+}
+}
+else
+{
+lean_object* x_66; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_66 = lean_apply_1(x_4, x_1);
+return x_66;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_balance_u2083_match__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_balance_u2083_match__2___rarg), 4, 0);
+return x_4;
+}
+}
 lean_object* l_Std_RBNode_balance_u2083___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -4953,7 +6572,7 @@ if (lean_obj_tag(x_4) == 0)
 uint8_t x_5; lean_object* x_6; 
 x_5 = 1;
 x_6 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_6, 0, x_4);
+lean_ctor_set(x_6, 0, x_1);
 lean_ctor_set(x_6, 1, x_2);
 lean_ctor_set(x_6, 2, x_3);
 lean_ctor_set(x_6, 3, x_4);
@@ -4976,344 +6595,320 @@ x_9 = lean_ctor_get(x_4, 3);
 lean_inc(x_9);
 if (lean_obj_tag(x_9) == 0)
 {
-uint8_t x_10; 
-x_10 = !lean_is_exclusive(x_4);
-if (x_10 == 0)
-{
-lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; 
-x_11 = lean_ctor_get(x_4, 3);
-lean_dec(x_11);
-x_12 = lean_ctor_get(x_4, 0);
-lean_dec(x_12);
-lean_ctor_set(x_4, 0, x_9);
-x_13 = 1;
-x_14 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_14, 0, x_9);
-lean_ctor_set(x_14, 1, x_2);
-lean_ctor_set(x_14, 2, x_3);
-lean_ctor_set(x_14, 3, x_4);
-lean_ctor_set_uint8(x_14, sizeof(void*)*4, x_13);
-return x_14;
+uint8_t x_10; lean_object* x_11; 
+x_10 = 1;
+x_11 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_11, 0, x_1);
+lean_ctor_set(x_11, 1, x_2);
+lean_ctor_set(x_11, 2, x_3);
+lean_ctor_set(x_11, 3, x_4);
+lean_ctor_set_uint8(x_11, sizeof(void*)*4, x_10);
+return x_11;
 }
 else
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; 
-x_15 = lean_ctor_get(x_4, 1);
-x_16 = lean_ctor_get(x_4, 2);
-lean_inc(x_16);
-lean_inc(x_15);
-lean_dec(x_4);
-x_17 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_17, 0, x_9);
-lean_ctor_set(x_17, 1, x_15);
-lean_ctor_set(x_17, 2, x_16);
-lean_ctor_set(x_17, 3, x_9);
-lean_ctor_set_uint8(x_17, sizeof(void*)*4, x_7);
-x_18 = 1;
-x_19 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_19, 0, x_9);
-lean_ctor_set(x_19, 1, x_2);
-lean_ctor_set(x_19, 2, x_3);
-lean_ctor_set(x_19, 3, x_17);
-lean_ctor_set_uint8(x_19, sizeof(void*)*4, x_18);
-return x_19;
-}
-}
-else
+uint8_t x_12; 
+x_12 = lean_ctor_get_uint8(x_9, sizeof(void*)*4);
+if (x_12 == 0)
 {
-uint8_t x_20; 
-x_20 = lean_ctor_get_uint8(x_9, sizeof(void*)*4);
-if (x_20 == 0)
+uint8_t x_13; 
+x_13 = !lean_is_exclusive(x_4);
+if (x_13 == 0)
 {
-uint8_t x_21; 
-x_21 = !lean_is_exclusive(x_4);
-if (x_21 == 0)
+lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; 
+x_14 = lean_ctor_get(x_4, 1);
+x_15 = lean_ctor_get(x_4, 2);
+x_16 = lean_ctor_get(x_4, 3);
+lean_dec(x_16);
+x_17 = lean_ctor_get(x_4, 0);
+lean_dec(x_17);
+x_18 = !lean_is_exclusive(x_9);
+if (x_18 == 0)
 {
-lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; 
-x_22 = lean_ctor_get(x_4, 1);
-x_23 = lean_ctor_get(x_4, 2);
-x_24 = lean_ctor_get(x_4, 3);
-lean_dec(x_24);
-x_25 = lean_ctor_get(x_4, 0);
-lean_dec(x_25);
-x_26 = !lean_is_exclusive(x_9);
-if (x_26 == 0)
-{
-lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; 
-x_27 = lean_ctor_get(x_9, 0);
-x_28 = lean_ctor_get(x_9, 1);
-x_29 = lean_ctor_get(x_9, 2);
-x_30 = lean_ctor_get(x_9, 3);
-x_31 = 1;
+lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; uint8_t x_24; lean_object* x_25; 
+x_19 = lean_ctor_get(x_9, 0);
+x_20 = lean_ctor_get(x_9, 1);
+x_21 = lean_ctor_get(x_9, 2);
+x_22 = lean_ctor_get(x_9, 3);
+x_23 = 1;
 lean_ctor_set(x_9, 3, x_8);
 lean_ctor_set(x_9, 2, x_3);
 lean_ctor_set(x_9, 1, x_2);
-lean_ctor_set(x_9, 0, x_8);
-lean_ctor_set_uint8(x_9, sizeof(void*)*4, x_31);
-lean_ctor_set(x_4, 3, x_30);
-lean_ctor_set(x_4, 2, x_29);
-lean_ctor_set(x_4, 1, x_28);
-lean_ctor_set(x_4, 0, x_27);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_31);
-x_32 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_32, 0, x_9);
-lean_ctor_set(x_32, 1, x_22);
-lean_ctor_set(x_32, 2, x_23);
-lean_ctor_set(x_32, 3, x_4);
-lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_20);
-return x_32;
+lean_ctor_set(x_9, 0, x_1);
+lean_ctor_set_uint8(x_9, sizeof(void*)*4, x_23);
+lean_ctor_set(x_4, 3, x_22);
+lean_ctor_set(x_4, 2, x_21);
+lean_ctor_set(x_4, 1, x_20);
+lean_ctor_set(x_4, 0, x_19);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_23);
+x_24 = 0;
+x_25 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_25, 0, x_9);
+lean_ctor_set(x_25, 1, x_14);
+lean_ctor_set(x_25, 2, x_15);
+lean_ctor_set(x_25, 3, x_4);
+lean_ctor_set_uint8(x_25, sizeof(void*)*4, x_24);
+return x_25;
 }
 else
 {
-lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_object* x_38; lean_object* x_39; 
-x_33 = lean_ctor_get(x_9, 0);
-x_34 = lean_ctor_get(x_9, 1);
-x_35 = lean_ctor_get(x_9, 2);
-x_36 = lean_ctor_get(x_9, 3);
-lean_inc(x_36);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; 
+x_26 = lean_ctor_get(x_9, 0);
+x_27 = lean_ctor_get(x_9, 1);
+x_28 = lean_ctor_get(x_9, 2);
+x_29 = lean_ctor_get(x_9, 3);
+lean_inc(x_29);
+lean_inc(x_28);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_dec(x_9);
+x_30 = 1;
+x_31 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_31, 0, x_1);
+lean_ctor_set(x_31, 1, x_2);
+lean_ctor_set(x_31, 2, x_3);
+lean_ctor_set(x_31, 3, x_8);
+lean_ctor_set_uint8(x_31, sizeof(void*)*4, x_30);
+lean_ctor_set(x_4, 3, x_29);
+lean_ctor_set(x_4, 2, x_28);
+lean_ctor_set(x_4, 1, x_27);
+lean_ctor_set(x_4, 0, x_26);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_30);
+x_32 = 0;
+x_33 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_33, 0, x_31);
+lean_ctor_set(x_33, 1, x_14);
+lean_ctor_set(x_33, 2, x_15);
+lean_ctor_set(x_33, 3, x_4);
+lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32);
+return x_33;
+}
+}
+else
+{
+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; uint8_t x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; lean_object* x_45; 
+x_34 = lean_ctor_get(x_4, 1);
+x_35 = lean_ctor_get(x_4, 2);
 lean_inc(x_35);
 lean_inc(x_34);
-lean_inc(x_33);
-lean_dec(x_9);
-x_37 = 1;
-x_38 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_38, 0, x_8);
-lean_ctor_set(x_38, 1, x_2);
-lean_ctor_set(x_38, 2, x_3);
-lean_ctor_set(x_38, 3, x_8);
-lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_37);
-lean_ctor_set(x_4, 3, x_36);
-lean_ctor_set(x_4, 2, x_35);
-lean_ctor_set(x_4, 1, x_34);
-lean_ctor_set(x_4, 0, x_33);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_37);
-x_39 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_39, 0, x_38);
-lean_ctor_set(x_39, 1, x_22);
-lean_ctor_set(x_39, 2, x_23);
-lean_ctor_set(x_39, 3, x_4);
-lean_ctor_set_uint8(x_39, sizeof(void*)*4, x_20);
-return x_39;
-}
-}
-else
-{
-lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; 
-x_40 = lean_ctor_get(x_4, 1);
-x_41 = lean_ctor_get(x_4, 2);
-lean_inc(x_41);
-lean_inc(x_40);
 lean_dec(x_4);
-x_42 = lean_ctor_get(x_9, 0);
-lean_inc(x_42);
-x_43 = lean_ctor_get(x_9, 1);
-lean_inc(x_43);
-x_44 = lean_ctor_get(x_9, 2);
-lean_inc(x_44);
-x_45 = lean_ctor_get(x_9, 3);
-lean_inc(x_45);
+x_36 = lean_ctor_get(x_9, 0);
+lean_inc(x_36);
+x_37 = lean_ctor_get(x_9, 1);
+lean_inc(x_37);
+x_38 = lean_ctor_get(x_9, 2);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_9, 3);
+lean_inc(x_39);
 if (lean_is_exclusive(x_9)) {
  lean_ctor_release(x_9, 0);
  lean_ctor_release(x_9, 1);
  lean_ctor_release(x_9, 2);
  lean_ctor_release(x_9, 3);
- x_46 = x_9;
+ x_40 = x_9;
 } else {
  lean_dec_ref(x_9);
- x_46 = lean_box(0);
+ x_40 = lean_box(0);
 }
-x_47 = 1;
-if (lean_is_scalar(x_46)) {
- x_48 = lean_alloc_ctor(1, 4, 1);
+x_41 = 1;
+if (lean_is_scalar(x_40)) {
+ x_42 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_48 = x_46;
+ x_42 = x_40;
 }
-lean_ctor_set(x_48, 0, x_8);
-lean_ctor_set(x_48, 1, x_2);
-lean_ctor_set(x_48, 2, x_3);
-lean_ctor_set(x_48, 3, x_8);
-lean_ctor_set_uint8(x_48, sizeof(void*)*4, x_47);
-x_49 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_49, 0, x_42);
-lean_ctor_set(x_49, 1, x_43);
-lean_ctor_set(x_49, 2, x_44);
-lean_ctor_set(x_49, 3, x_45);
-lean_ctor_set_uint8(x_49, sizeof(void*)*4, x_47);
-x_50 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_50, 0, x_48);
-lean_ctor_set(x_50, 1, x_40);
-lean_ctor_set(x_50, 2, x_41);
-lean_ctor_set(x_50, 3, x_49);
-lean_ctor_set_uint8(x_50, sizeof(void*)*4, x_20);
-return x_50;
+lean_ctor_set(x_42, 0, x_1);
+lean_ctor_set(x_42, 1, x_2);
+lean_ctor_set(x_42, 2, x_3);
+lean_ctor_set(x_42, 3, x_8);
+lean_ctor_set_uint8(x_42, sizeof(void*)*4, x_41);
+x_43 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_43, 0, x_36);
+lean_ctor_set(x_43, 1, x_37);
+lean_ctor_set(x_43, 2, x_38);
+lean_ctor_set(x_43, 3, x_39);
+lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_41);
+x_44 = 0;
+x_45 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_45, 0, x_42);
+lean_ctor_set(x_45, 1, x_34);
+lean_ctor_set(x_45, 2, x_35);
+lean_ctor_set(x_45, 3, x_43);
+lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_44);
+return x_45;
 }
 }
 else
 {
-uint8_t x_51; 
-x_51 = !lean_is_exclusive(x_9);
-if (x_51 == 0)
+uint8_t x_46; 
+x_46 = !lean_is_exclusive(x_9);
+if (x_46 == 0)
 {
-lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; 
-x_52 = lean_ctor_get(x_9, 3);
-lean_dec(x_52);
-x_53 = lean_ctor_get(x_9, 2);
-lean_dec(x_53);
-x_54 = lean_ctor_get(x_9, 1);
-lean_dec(x_54);
-x_55 = lean_ctor_get(x_9, 0);
-lean_dec(x_55);
+lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; 
+x_47 = lean_ctor_get(x_9, 3);
+lean_dec(x_47);
+x_48 = lean_ctor_get(x_9, 2);
+lean_dec(x_48);
+x_49 = lean_ctor_get(x_9, 1);
+lean_dec(x_49);
+x_50 = lean_ctor_get(x_9, 0);
+lean_dec(x_50);
+x_51 = 1;
 lean_ctor_set(x_9, 3, x_4);
 lean_ctor_set(x_9, 2, x_3);
 lean_ctor_set(x_9, 1, x_2);
-lean_ctor_set(x_9, 0, x_8);
+lean_ctor_set(x_9, 0, x_1);
+lean_ctor_set_uint8(x_9, sizeof(void*)*4, x_51);
 return x_9;
 }
 else
 {
-lean_object* x_56; 
+uint8_t x_52; lean_object* x_53; 
 lean_dec(x_9);
-x_56 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_56, 0, x_8);
-lean_ctor_set(x_56, 1, x_2);
-lean_ctor_set(x_56, 2, x_3);
-lean_ctor_set(x_56, 3, x_4);
-lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_20);
-return x_56;
+x_52 = 1;
+x_53 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_53, 0, x_1);
+lean_ctor_set(x_53, 1, x_2);
+lean_ctor_set(x_53, 2, x_3);
+lean_ctor_set(x_53, 3, x_4);
+lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_52);
+return x_53;
 }
 }
 }
 }
 else
 {
-uint8_t x_57; 
-x_57 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
-if (x_57 == 0)
+uint8_t x_54; 
+x_54 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
+if (x_54 == 0)
 {
-lean_object* x_58; 
-x_58 = lean_ctor_get(x_4, 3);
-lean_inc(x_58);
-if (lean_obj_tag(x_58) == 0)
+lean_object* x_55; 
+x_55 = lean_ctor_get(x_4, 3);
+lean_inc(x_55);
+if (lean_obj_tag(x_55) == 0)
 {
-uint8_t x_59; 
-x_59 = !lean_is_exclusive(x_4);
+uint8_t x_56; 
+x_56 = !lean_is_exclusive(x_4);
+if (x_56 == 0)
+{
+lean_object* x_57; lean_object* x_58; uint8_t x_59; 
+x_57 = lean_ctor_get(x_4, 3);
+lean_dec(x_57);
+x_58 = lean_ctor_get(x_4, 0);
+lean_dec(x_58);
+x_59 = !lean_is_exclusive(x_8);
 if (x_59 == 0)
 {
-lean_object* x_60; lean_object* x_61; uint8_t x_62; 
-x_60 = lean_ctor_get(x_4, 3);
-lean_dec(x_60);
-x_61 = lean_ctor_get(x_4, 0);
-lean_dec(x_61);
-x_62 = !lean_is_exclusive(x_8);
-if (x_62 == 0)
-{
-lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; 
-x_63 = lean_ctor_get(x_8, 0);
-x_64 = lean_ctor_get(x_8, 1);
-x_65 = lean_ctor_get(x_8, 2);
-x_66 = lean_ctor_get(x_8, 3);
-x_67 = 1;
-lean_ctor_set(x_8, 3, x_63);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; uint8_t x_65; lean_object* x_66; 
+x_60 = lean_ctor_get(x_8, 0);
+x_61 = lean_ctor_get(x_8, 1);
+x_62 = lean_ctor_get(x_8, 2);
+x_63 = lean_ctor_get(x_8, 3);
+x_64 = 1;
+lean_ctor_set(x_8, 3, x_60);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
-lean_ctor_set(x_8, 0, x_58);
-lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_67);
-lean_ctor_set(x_4, 0, x_66);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_67);
-x_68 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_68, 0, x_8);
-lean_ctor_set(x_68, 1, x_64);
-lean_ctor_set(x_68, 2, x_65);
-lean_ctor_set(x_68, 3, x_4);
-lean_ctor_set_uint8(x_68, sizeof(void*)*4, x_57);
-return x_68;
+lean_ctor_set(x_8, 0, x_1);
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_64);
+lean_ctor_set(x_4, 0, x_63);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_64);
+x_65 = 0;
+x_66 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_66, 0, x_8);
+lean_ctor_set(x_66, 1, x_61);
+lean_ctor_set(x_66, 2, x_62);
+lean_ctor_set(x_66, 3, x_4);
+lean_ctor_set_uint8(x_66, sizeof(void*)*4, x_65);
+return x_66;
 }
 else
 {
-lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; 
-x_69 = lean_ctor_get(x_8, 0);
-x_70 = lean_ctor_get(x_8, 1);
-x_71 = lean_ctor_get(x_8, 2);
-x_72 = lean_ctor_get(x_8, 3);
-lean_inc(x_72);
-lean_inc(x_71);
+lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; lean_object* x_72; uint8_t x_73; lean_object* x_74; 
+x_67 = lean_ctor_get(x_8, 0);
+x_68 = lean_ctor_get(x_8, 1);
+x_69 = lean_ctor_get(x_8, 2);
+x_70 = lean_ctor_get(x_8, 3);
 lean_inc(x_70);
 lean_inc(x_69);
+lean_inc(x_68);
+lean_inc(x_67);
 lean_dec(x_8);
-x_73 = 1;
+x_71 = 1;
+x_72 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_72, 0, x_1);
+lean_ctor_set(x_72, 1, x_2);
+lean_ctor_set(x_72, 2, x_3);
+lean_ctor_set(x_72, 3, x_67);
+lean_ctor_set_uint8(x_72, sizeof(void*)*4, x_71);
+lean_ctor_set(x_4, 0, x_70);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_71);
+x_73 = 0;
 x_74 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_74, 0, x_58);
-lean_ctor_set(x_74, 1, x_2);
-lean_ctor_set(x_74, 2, x_3);
-lean_ctor_set(x_74, 3, x_69);
+lean_ctor_set(x_74, 0, x_72);
+lean_ctor_set(x_74, 1, x_68);
+lean_ctor_set(x_74, 2, x_69);
+lean_ctor_set(x_74, 3, x_4);
 lean_ctor_set_uint8(x_74, sizeof(void*)*4, x_73);
-lean_ctor_set(x_4, 0, x_72);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_73);
-x_75 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_75, 0, x_74);
-lean_ctor_set(x_75, 1, x_70);
-lean_ctor_set(x_75, 2, x_71);
-lean_ctor_set(x_75, 3, x_4);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_57);
-return x_75;
+return x_74;
 }
 }
 else
 {
-lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; uint8_t x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-x_76 = lean_ctor_get(x_4, 1);
-x_77 = lean_ctor_get(x_4, 2);
-lean_inc(x_77);
+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; lean_object* x_83; lean_object* x_84; uint8_t x_85; lean_object* x_86; 
+x_75 = lean_ctor_get(x_4, 1);
+x_76 = lean_ctor_get(x_4, 2);
 lean_inc(x_76);
+lean_inc(x_75);
 lean_dec(x_4);
-x_78 = lean_ctor_get(x_8, 0);
+x_77 = lean_ctor_get(x_8, 0);
+lean_inc(x_77);
+x_78 = lean_ctor_get(x_8, 1);
 lean_inc(x_78);
-x_79 = lean_ctor_get(x_8, 1);
+x_79 = lean_ctor_get(x_8, 2);
 lean_inc(x_79);
-x_80 = lean_ctor_get(x_8, 2);
+x_80 = lean_ctor_get(x_8, 3);
 lean_inc(x_80);
-x_81 = lean_ctor_get(x_8, 3);
-lean_inc(x_81);
 if (lean_is_exclusive(x_8)) {
  lean_ctor_release(x_8, 0);
  lean_ctor_release(x_8, 1);
  lean_ctor_release(x_8, 2);
  lean_ctor_release(x_8, 3);
- x_82 = x_8;
+ x_81 = x_8;
 } else {
  lean_dec_ref(x_8);
- x_82 = lean_box(0);
+ x_81 = lean_box(0);
 }
-x_83 = 1;
-if (lean_is_scalar(x_82)) {
- x_84 = lean_alloc_ctor(1, 4, 1);
+x_82 = 1;
+if (lean_is_scalar(x_81)) {
+ x_83 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_84 = x_82;
+ x_83 = x_81;
 }
-lean_ctor_set(x_84, 0, x_58);
-lean_ctor_set(x_84, 1, x_2);
-lean_ctor_set(x_84, 2, x_3);
-lean_ctor_set(x_84, 3, x_78);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_83);
-x_85 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_85, 0, x_81);
-lean_ctor_set(x_85, 1, x_76);
-lean_ctor_set(x_85, 2, x_77);
-lean_ctor_set(x_85, 3, x_58);
-lean_ctor_set_uint8(x_85, sizeof(void*)*4, x_83);
+lean_ctor_set(x_83, 0, x_1);
+lean_ctor_set(x_83, 1, x_2);
+lean_ctor_set(x_83, 2, x_3);
+lean_ctor_set(x_83, 3, x_77);
+lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_82);
+x_84 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_84, 0, x_80);
+lean_ctor_set(x_84, 1, x_75);
+lean_ctor_set(x_84, 2, x_76);
+lean_ctor_set(x_84, 3, x_55);
+lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_82);
+x_85 = 0;
 x_86 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_86, 0, x_84);
-lean_ctor_set(x_86, 1, x_79);
-lean_ctor_set(x_86, 2, x_80);
-lean_ctor_set(x_86, 3, x_85);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_57);
+lean_ctor_set(x_86, 0, x_83);
+lean_ctor_set(x_86, 1, x_78);
+lean_ctor_set(x_86, 2, x_79);
+lean_ctor_set(x_86, 3, x_84);
+lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_85);
 return x_86;
 }
 }
 else
 {
 uint8_t x_87; 
-x_87 = lean_ctor_get_uint8(x_58, sizeof(void*)*4);
+x_87 = lean_ctor_get_uint8(x_55, sizeof(void*)*4);
 if (x_87 == 0)
 {
 uint8_t x_88; 
@@ -5331,24 +6926,24 @@ x_93 = !lean_is_exclusive(x_8);
 if (x_93 == 0)
 {
 uint8_t x_94; 
-x_94 = !lean_is_exclusive(x_58);
+x_94 = !lean_is_exclusive(x_55);
 if (x_94 == 0)
 {
-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; uint8_t x_103; lean_object* x_104; 
+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; uint8_t x_103; uint8_t x_104; lean_object* x_105; 
 x_95 = lean_ctor_get(x_8, 0);
 x_96 = lean_ctor_get(x_8, 1);
 x_97 = lean_ctor_get(x_8, 2);
 x_98 = lean_ctor_get(x_8, 3);
-x_99 = lean_ctor_get(x_58, 0);
-x_100 = lean_ctor_get(x_58, 1);
-x_101 = lean_ctor_get(x_58, 2);
-x_102 = lean_ctor_get(x_58, 3);
-lean_ctor_set(x_58, 3, x_98);
-lean_ctor_set(x_58, 2, x_97);
-lean_ctor_set(x_58, 1, x_96);
-lean_ctor_set(x_58, 0, x_95);
+x_99 = lean_ctor_get(x_55, 0);
+x_100 = lean_ctor_get(x_55, 1);
+x_101 = lean_ctor_get(x_55, 2);
+x_102 = lean_ctor_get(x_55, 3);
+lean_ctor_set(x_55, 3, x_98);
+lean_ctor_set(x_55, 2, x_97);
+lean_ctor_set(x_55, 1, x_96);
+lean_ctor_set(x_55, 0, x_95);
 x_103 = 1;
-lean_ctor_set(x_8, 3, x_58);
+lean_ctor_set(x_8, 3, x_55);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
 lean_ctor_set(x_8, 0, x_1);
@@ -5358,631 +6953,587 @@ lean_ctor_set(x_4, 2, x_101);
 lean_ctor_set(x_4, 1, x_100);
 lean_ctor_set(x_4, 0, x_99);
 lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_103);
-x_104 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_104, 0, x_8);
-lean_ctor_set(x_104, 1, x_89);
-lean_ctor_set(x_104, 2, x_90);
-lean_ctor_set(x_104, 3, x_4);
-lean_ctor_set_uint8(x_104, sizeof(void*)*4, x_87);
-return x_104;
+x_104 = 0;
+x_105 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_105, 0, x_8);
+lean_ctor_set(x_105, 1, x_89);
+lean_ctor_set(x_105, 2, x_90);
+lean_ctor_set(x_105, 3, x_4);
+lean_ctor_set_uint8(x_105, sizeof(void*)*4, x_104);
+return x_105;
 }
 else
 {
-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; uint8_t x_114; lean_object* x_115; 
-x_105 = lean_ctor_get(x_8, 0);
-x_106 = lean_ctor_get(x_8, 1);
-x_107 = lean_ctor_get(x_8, 2);
-x_108 = lean_ctor_get(x_8, 3);
-x_109 = lean_ctor_get(x_58, 0);
-x_110 = lean_ctor_get(x_58, 1);
-x_111 = lean_ctor_get(x_58, 2);
-x_112 = lean_ctor_get(x_58, 3);
+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; uint8_t x_115; uint8_t x_116; lean_object* x_117; 
+x_106 = lean_ctor_get(x_8, 0);
+x_107 = lean_ctor_get(x_8, 1);
+x_108 = lean_ctor_get(x_8, 2);
+x_109 = lean_ctor_get(x_8, 3);
+x_110 = lean_ctor_get(x_55, 0);
+x_111 = lean_ctor_get(x_55, 1);
+x_112 = lean_ctor_get(x_55, 2);
+x_113 = lean_ctor_get(x_55, 3);
+lean_inc(x_113);
 lean_inc(x_112);
 lean_inc(x_111);
 lean_inc(x_110);
-lean_inc(x_109);
-lean_dec(x_58);
-x_113 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_113, 0, x_105);
-lean_ctor_set(x_113, 1, x_106);
-lean_ctor_set(x_113, 2, x_107);
-lean_ctor_set(x_113, 3, x_108);
-lean_ctor_set_uint8(x_113, sizeof(void*)*4, x_87);
-x_114 = 1;
-lean_ctor_set(x_8, 3, x_113);
+lean_dec(x_55);
+x_114 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_114, 0, x_106);
+lean_ctor_set(x_114, 1, x_107);
+lean_ctor_set(x_114, 2, x_108);
+lean_ctor_set(x_114, 3, x_109);
+lean_ctor_set_uint8(x_114, sizeof(void*)*4, x_87);
+x_115 = 1;
+lean_ctor_set(x_8, 3, x_114);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
 lean_ctor_set(x_8, 0, x_1);
-lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_114);
-lean_ctor_set(x_4, 3, x_112);
-lean_ctor_set(x_4, 2, x_111);
-lean_ctor_set(x_4, 1, x_110);
-lean_ctor_set(x_4, 0, x_109);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_114);
-x_115 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_115, 0, x_8);
-lean_ctor_set(x_115, 1, x_89);
-lean_ctor_set(x_115, 2, x_90);
-lean_ctor_set(x_115, 3, x_4);
-lean_ctor_set_uint8(x_115, sizeof(void*)*4, x_87);
-return x_115;
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_115);
+lean_ctor_set(x_4, 3, x_113);
+lean_ctor_set(x_4, 2, x_112);
+lean_ctor_set(x_4, 1, x_111);
+lean_ctor_set(x_4, 0, x_110);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_115);
+x_116 = 0;
+x_117 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_117, 0, x_8);
+lean_ctor_set(x_117, 1, x_89);
+lean_ctor_set(x_117, 2, x_90);
+lean_ctor_set(x_117, 3, x_4);
+lean_ctor_set_uint8(x_117, sizeof(void*)*4, x_116);
+return x_117;
 }
 }
 else
 {
-lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; lean_object* x_127; lean_object* x_128; 
-x_116 = lean_ctor_get(x_8, 0);
-x_117 = lean_ctor_get(x_8, 1);
-x_118 = lean_ctor_get(x_8, 2);
-x_119 = lean_ctor_get(x_8, 3);
+lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; uint8_t x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; 
+x_118 = lean_ctor_get(x_8, 0);
+x_119 = lean_ctor_get(x_8, 1);
+x_120 = lean_ctor_get(x_8, 2);
+x_121 = lean_ctor_get(x_8, 3);
+lean_inc(x_121);
+lean_inc(x_120);
 lean_inc(x_119);
 lean_inc(x_118);
-lean_inc(x_117);
-lean_inc(x_116);
 lean_dec(x_8);
-x_120 = lean_ctor_get(x_58, 0);
-lean_inc(x_120);
-x_121 = lean_ctor_get(x_58, 1);
-lean_inc(x_121);
-x_122 = lean_ctor_get(x_58, 2);
+x_122 = lean_ctor_get(x_55, 0);
 lean_inc(x_122);
-x_123 = lean_ctor_get(x_58, 3);
+x_123 = lean_ctor_get(x_55, 1);
 lean_inc(x_123);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- lean_ctor_release(x_58, 2);
- lean_ctor_release(x_58, 3);
- x_124 = x_58;
+x_124 = lean_ctor_get(x_55, 2);
+lean_inc(x_124);
+x_125 = lean_ctor_get(x_55, 3);
+lean_inc(x_125);
+if (lean_is_exclusive(x_55)) {
+ lean_ctor_release(x_55, 0);
+ lean_ctor_release(x_55, 1);
+ lean_ctor_release(x_55, 2);
+ lean_ctor_release(x_55, 3);
+ x_126 = x_55;
 } else {
- lean_dec_ref(x_58);
- x_124 = lean_box(0);
+ lean_dec_ref(x_55);
+ x_126 = lean_box(0);
 }
-if (lean_is_scalar(x_124)) {
- x_125 = lean_alloc_ctor(1, 4, 1);
+if (lean_is_scalar(x_126)) {
+ x_127 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_125 = x_124;
+ x_127 = x_126;
 }
-lean_ctor_set(x_125, 0, x_116);
-lean_ctor_set(x_125, 1, x_117);
-lean_ctor_set(x_125, 2, x_118);
-lean_ctor_set(x_125, 3, x_119);
-lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_87);
-x_126 = 1;
-x_127 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_127, 0, x_1);
-lean_ctor_set(x_127, 1, x_2);
-lean_ctor_set(x_127, 2, x_3);
-lean_ctor_set(x_127, 3, x_125);
-lean_ctor_set_uint8(x_127, sizeof(void*)*4, x_126);
-lean_ctor_set(x_4, 3, x_123);
-lean_ctor_set(x_4, 2, x_122);
-lean_ctor_set(x_4, 1, x_121);
-lean_ctor_set(x_4, 0, x_120);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_126);
-x_128 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_128, 0, x_127);
-lean_ctor_set(x_128, 1, x_89);
-lean_ctor_set(x_128, 2, x_90);
-lean_ctor_set(x_128, 3, x_4);
-lean_ctor_set_uint8(x_128, sizeof(void*)*4, x_87);
-return x_128;
+lean_ctor_set(x_127, 0, x_118);
+lean_ctor_set(x_127, 1, x_119);
+lean_ctor_set(x_127, 2, x_120);
+lean_ctor_set(x_127, 3, x_121);
+lean_ctor_set_uint8(x_127, sizeof(void*)*4, x_87);
+x_128 = 1;
+x_129 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_129, 0, x_1);
+lean_ctor_set(x_129, 1, x_2);
+lean_ctor_set(x_129, 2, x_3);
+lean_ctor_set(x_129, 3, x_127);
+lean_ctor_set_uint8(x_129, sizeof(void*)*4, x_128);
+lean_ctor_set(x_4, 3, x_125);
+lean_ctor_set(x_4, 2, x_124);
+lean_ctor_set(x_4, 1, x_123);
+lean_ctor_set(x_4, 0, x_122);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_128);
+x_130 = 0;
+x_131 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_131, 0, x_129);
+lean_ctor_set(x_131, 1, x_89);
+lean_ctor_set(x_131, 2, x_90);
+lean_ctor_set(x_131, 3, x_4);
+lean_ctor_set_uint8(x_131, sizeof(void*)*4, x_130);
+return x_131;
 }
 }
 else
 {
-lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; uint8_t x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; 
-x_129 = lean_ctor_get(x_4, 1);
-x_130 = lean_ctor_get(x_4, 2);
-lean_inc(x_130);
-lean_inc(x_129);
-lean_dec(x_4);
-x_131 = lean_ctor_get(x_8, 0);
-lean_inc(x_131);
-x_132 = lean_ctor_get(x_8, 1);
-lean_inc(x_132);
-x_133 = lean_ctor_get(x_8, 2);
+lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; uint8_t x_145; lean_object* x_146; lean_object* x_147; uint8_t x_148; lean_object* x_149; 
+x_132 = lean_ctor_get(x_4, 1);
+x_133 = lean_ctor_get(x_4, 2);
 lean_inc(x_133);
-x_134 = lean_ctor_get(x_8, 3);
+lean_inc(x_132);
+lean_dec(x_4);
+x_134 = lean_ctor_get(x_8, 0);
 lean_inc(x_134);
+x_135 = lean_ctor_get(x_8, 1);
+lean_inc(x_135);
+x_136 = lean_ctor_get(x_8, 2);
+lean_inc(x_136);
+x_137 = lean_ctor_get(x_8, 3);
+lean_inc(x_137);
 if (lean_is_exclusive(x_8)) {
  lean_ctor_release(x_8, 0);
  lean_ctor_release(x_8, 1);
  lean_ctor_release(x_8, 2);
  lean_ctor_release(x_8, 3);
- x_135 = x_8;
+ x_138 = x_8;
 } else {
  lean_dec_ref(x_8);
- x_135 = lean_box(0);
+ x_138 = lean_box(0);
 }
-x_136 = lean_ctor_get(x_58, 0);
-lean_inc(x_136);
-x_137 = lean_ctor_get(x_58, 1);
-lean_inc(x_137);
-x_138 = lean_ctor_get(x_58, 2);
-lean_inc(x_138);
-x_139 = lean_ctor_get(x_58, 3);
+x_139 = lean_ctor_get(x_55, 0);
 lean_inc(x_139);
-if (lean_is_exclusive(x_58)) {
- lean_ctor_release(x_58, 0);
- lean_ctor_release(x_58, 1);
- lean_ctor_release(x_58, 2);
- lean_ctor_release(x_58, 3);
- x_140 = x_58;
+x_140 = lean_ctor_get(x_55, 1);
+lean_inc(x_140);
+x_141 = lean_ctor_get(x_55, 2);
+lean_inc(x_141);
+x_142 = lean_ctor_get(x_55, 3);
+lean_inc(x_142);
+if (lean_is_exclusive(x_55)) {
+ lean_ctor_release(x_55, 0);
+ lean_ctor_release(x_55, 1);
+ lean_ctor_release(x_55, 2);
+ lean_ctor_release(x_55, 3);
+ x_143 = x_55;
 } else {
- lean_dec_ref(x_58);
- x_140 = lean_box(0);
+ lean_dec_ref(x_55);
+ x_143 = lean_box(0);
 }
-if (lean_is_scalar(x_140)) {
- x_141 = lean_alloc_ctor(1, 4, 1);
+if (lean_is_scalar(x_143)) {
+ x_144 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_141 = x_140;
+ x_144 = x_143;
 }
-lean_ctor_set(x_141, 0, x_131);
-lean_ctor_set(x_141, 1, x_132);
-lean_ctor_set(x_141, 2, x_133);
-lean_ctor_set(x_141, 3, x_134);
-lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_87);
-x_142 = 1;
-if (lean_is_scalar(x_135)) {
- x_143 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_144, 0, x_134);
+lean_ctor_set(x_144, 1, x_135);
+lean_ctor_set(x_144, 2, x_136);
+lean_ctor_set(x_144, 3, x_137);
+lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_87);
+x_145 = 1;
+if (lean_is_scalar(x_138)) {
+ x_146 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_143 = x_135;
+ x_146 = x_138;
 }
-lean_ctor_set(x_143, 0, x_1);
-lean_ctor_set(x_143, 1, x_2);
-lean_ctor_set(x_143, 2, x_3);
-lean_ctor_set(x_143, 3, x_141);
-lean_ctor_set_uint8(x_143, sizeof(void*)*4, x_142);
-x_144 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_144, 0, x_136);
-lean_ctor_set(x_144, 1, x_137);
-lean_ctor_set(x_144, 2, x_138);
-lean_ctor_set(x_144, 3, x_139);
-lean_ctor_set_uint8(x_144, sizeof(void*)*4, x_142);
-x_145 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_145, 0, x_143);
-lean_ctor_set(x_145, 1, x_129);
-lean_ctor_set(x_145, 2, x_130);
-lean_ctor_set(x_145, 3, x_144);
-lean_ctor_set_uint8(x_145, sizeof(void*)*4, x_87);
-return x_145;
+lean_ctor_set(x_146, 0, x_1);
+lean_ctor_set(x_146, 1, x_2);
+lean_ctor_set(x_146, 2, x_3);
+lean_ctor_set(x_146, 3, x_144);
+lean_ctor_set_uint8(x_146, sizeof(void*)*4, x_145);
+x_147 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_147, 0, x_139);
+lean_ctor_set(x_147, 1, x_140);
+lean_ctor_set(x_147, 2, x_141);
+lean_ctor_set(x_147, 3, x_142);
+lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_145);
+x_148 = 0;
+x_149 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_149, 0, x_146);
+lean_ctor_set(x_149, 1, x_132);
+lean_ctor_set(x_149, 2, x_133);
+lean_ctor_set(x_149, 3, x_147);
+lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_148);
+return x_149;
 }
 }
 else
 {
-uint8_t x_146; 
-x_146 = !lean_is_exclusive(x_4);
-if (x_146 == 0)
+uint8_t x_150; 
+x_150 = !lean_is_exclusive(x_4);
+if (x_150 == 0)
 {
-lean_object* x_147; lean_object* x_148; uint8_t x_149; 
-x_147 = lean_ctor_get(x_4, 3);
-lean_dec(x_147);
-x_148 = lean_ctor_get(x_4, 0);
-lean_dec(x_148);
-x_149 = !lean_is_exclusive(x_8);
-if (x_149 == 0)
+lean_object* x_151; lean_object* x_152; uint8_t x_153; 
+x_151 = lean_ctor_get(x_4, 3);
+lean_dec(x_151);
+x_152 = lean_ctor_get(x_4, 0);
+lean_dec(x_152);
+x_153 = !lean_is_exclusive(x_8);
+if (x_153 == 0)
 {
-lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; 
-x_150 = lean_ctor_get(x_8, 0);
-x_151 = lean_ctor_get(x_8, 1);
-x_152 = lean_ctor_get(x_8, 2);
-x_153 = lean_ctor_get(x_8, 3);
-lean_ctor_set(x_8, 3, x_150);
+lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; uint8_t x_158; uint8_t x_159; lean_object* x_160; 
+x_154 = lean_ctor_get(x_8, 0);
+x_155 = lean_ctor_get(x_8, 1);
+x_156 = lean_ctor_get(x_8, 2);
+x_157 = lean_ctor_get(x_8, 3);
+x_158 = 1;
+lean_ctor_set(x_8, 3, x_154);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
 lean_ctor_set(x_8, 0, x_1);
-lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_87);
-lean_ctor_set(x_4, 0, x_153);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_87);
-x_154 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_154, 0, x_8);
-lean_ctor_set(x_154, 1, x_151);
-lean_ctor_set(x_154, 2, x_152);
-lean_ctor_set(x_154, 3, x_4);
-lean_ctor_set_uint8(x_154, sizeof(void*)*4, x_57);
-return x_154;
-}
-else
-{
-lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; 
-x_155 = lean_ctor_get(x_8, 0);
-x_156 = lean_ctor_get(x_8, 1);
-x_157 = lean_ctor_get(x_8, 2);
-x_158 = lean_ctor_get(x_8, 3);
-lean_inc(x_158);
-lean_inc(x_157);
-lean_inc(x_156);
-lean_inc(x_155);
-lean_dec(x_8);
-x_159 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_159, 0, x_1);
-lean_ctor_set(x_159, 1, x_2);
-lean_ctor_set(x_159, 2, x_3);
-lean_ctor_set(x_159, 3, x_155);
-lean_ctor_set_uint8(x_159, sizeof(void*)*4, x_87);
-lean_ctor_set(x_4, 0, x_158);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_87);
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_158);
+lean_ctor_set(x_4, 0, x_157);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_158);
+x_159 = 0;
 x_160 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_160, 0, x_159);
-lean_ctor_set(x_160, 1, x_156);
-lean_ctor_set(x_160, 2, x_157);
+lean_ctor_set(x_160, 0, x_8);
+lean_ctor_set(x_160, 1, x_155);
+lean_ctor_set(x_160, 2, x_156);
 lean_ctor_set(x_160, 3, x_4);
-lean_ctor_set_uint8(x_160, sizeof(void*)*4, x_57);
+lean_ctor_set_uint8(x_160, sizeof(void*)*4, x_159);
 return x_160;
 }
+else
+{
+lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; uint8_t x_165; lean_object* x_166; uint8_t x_167; lean_object* x_168; 
+x_161 = lean_ctor_get(x_8, 0);
+x_162 = lean_ctor_get(x_8, 1);
+x_163 = lean_ctor_get(x_8, 2);
+x_164 = lean_ctor_get(x_8, 3);
+lean_inc(x_164);
+lean_inc(x_163);
+lean_inc(x_162);
+lean_inc(x_161);
+lean_dec(x_8);
+x_165 = 1;
+x_166 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_166, 0, x_1);
+lean_ctor_set(x_166, 1, x_2);
+lean_ctor_set(x_166, 2, x_3);
+lean_ctor_set(x_166, 3, x_161);
+lean_ctor_set_uint8(x_166, sizeof(void*)*4, x_165);
+lean_ctor_set(x_4, 0, x_164);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_165);
+x_167 = 0;
+x_168 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_168, 0, x_166);
+lean_ctor_set(x_168, 1, x_162);
+lean_ctor_set(x_168, 2, x_163);
+lean_ctor_set(x_168, 3, x_4);
+lean_ctor_set_uint8(x_168, sizeof(void*)*4, x_167);
+return x_168;
+}
 }
 else
 {
-lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; 
-x_161 = lean_ctor_get(x_4, 1);
-x_162 = lean_ctor_get(x_4, 2);
-lean_inc(x_162);
-lean_inc(x_161);
+lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; uint8_t x_176; lean_object* x_177; lean_object* x_178; uint8_t x_179; lean_object* x_180; 
+x_169 = lean_ctor_get(x_4, 1);
+x_170 = lean_ctor_get(x_4, 2);
+lean_inc(x_170);
+lean_inc(x_169);
 lean_dec(x_4);
-x_163 = lean_ctor_get(x_8, 0);
-lean_inc(x_163);
-x_164 = lean_ctor_get(x_8, 1);
-lean_inc(x_164);
-x_165 = lean_ctor_get(x_8, 2);
-lean_inc(x_165);
-x_166 = lean_ctor_get(x_8, 3);
-lean_inc(x_166);
+x_171 = lean_ctor_get(x_8, 0);
+lean_inc(x_171);
+x_172 = lean_ctor_get(x_8, 1);
+lean_inc(x_172);
+x_173 = lean_ctor_get(x_8, 2);
+lean_inc(x_173);
+x_174 = lean_ctor_get(x_8, 3);
+lean_inc(x_174);
 if (lean_is_exclusive(x_8)) {
  lean_ctor_release(x_8, 0);
  lean_ctor_release(x_8, 1);
  lean_ctor_release(x_8, 2);
  lean_ctor_release(x_8, 3);
- x_167 = x_8;
+ x_175 = x_8;
 } else {
  lean_dec_ref(x_8);
- x_167 = lean_box(0);
+ x_175 = lean_box(0);
 }
-if (lean_is_scalar(x_167)) {
- x_168 = lean_alloc_ctor(1, 4, 1);
+x_176 = 1;
+if (lean_is_scalar(x_175)) {
+ x_177 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_168 = x_167;
+ x_177 = x_175;
 }
-lean_ctor_set(x_168, 0, x_1);
-lean_ctor_set(x_168, 1, x_2);
-lean_ctor_set(x_168, 2, x_3);
-lean_ctor_set(x_168, 3, x_163);
-lean_ctor_set_uint8(x_168, sizeof(void*)*4, x_87);
-x_169 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_169, 0, x_166);
-lean_ctor_set(x_169, 1, x_161);
-lean_ctor_set(x_169, 2, x_162);
-lean_ctor_set(x_169, 3, x_58);
-lean_ctor_set_uint8(x_169, sizeof(void*)*4, x_87);
-x_170 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_170, 0, x_168);
-lean_ctor_set(x_170, 1, x_164);
-lean_ctor_set(x_170, 2, x_165);
-lean_ctor_set(x_170, 3, x_169);
-lean_ctor_set_uint8(x_170, sizeof(void*)*4, x_57);
-return x_170;
+lean_ctor_set(x_177, 0, x_1);
+lean_ctor_set(x_177, 1, x_2);
+lean_ctor_set(x_177, 2, x_3);
+lean_ctor_set(x_177, 3, x_171);
+lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_176);
+x_178 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_178, 0, x_174);
+lean_ctor_set(x_178, 1, x_169);
+lean_ctor_set(x_178, 2, x_170);
+lean_ctor_set(x_178, 3, x_55);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_176);
+x_179 = 0;
+x_180 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_180, 0, x_177);
+lean_ctor_set(x_180, 1, x_172);
+lean_ctor_set(x_180, 2, x_173);
+lean_ctor_set(x_180, 3, x_178);
+lean_ctor_set_uint8(x_180, sizeof(void*)*4, x_179);
+return x_180;
 }
 }
 }
 }
 else
 {
-lean_object* x_171; 
-x_171 = lean_ctor_get(x_4, 3);
-lean_inc(x_171);
-if (lean_obj_tag(x_171) == 0)
+lean_object* x_181; 
+x_181 = lean_ctor_get(x_4, 3);
+lean_inc(x_181);
+if (lean_obj_tag(x_181) == 0)
 {
-uint8_t x_172; 
-x_172 = !lean_is_exclusive(x_8);
-if (x_172 == 0)
+uint8_t x_182; 
+x_182 = !lean_is_exclusive(x_8);
+if (x_182 == 0)
 {
-lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; 
-x_173 = lean_ctor_get(x_8, 3);
-lean_dec(x_173);
-x_174 = lean_ctor_get(x_8, 2);
-lean_dec(x_174);
-x_175 = lean_ctor_get(x_8, 1);
-lean_dec(x_175);
-x_176 = lean_ctor_get(x_8, 0);
-lean_dec(x_176);
+lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; uint8_t x_187; 
+x_183 = lean_ctor_get(x_8, 3);
+lean_dec(x_183);
+x_184 = lean_ctor_get(x_8, 2);
+lean_dec(x_184);
+x_185 = lean_ctor_get(x_8, 1);
+lean_dec(x_185);
+x_186 = lean_ctor_get(x_8, 0);
+lean_dec(x_186);
+x_187 = 1;
 lean_ctor_set(x_8, 3, x_4);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
-lean_ctor_set(x_8, 0, x_171);
+lean_ctor_set(x_8, 0, x_1);
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_187);
 return x_8;
 }
 else
 {
-lean_object* x_177; 
+uint8_t x_188; lean_object* x_189; 
 lean_dec(x_8);
-x_177 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_177, 0, x_171);
-lean_ctor_set(x_177, 1, x_2);
-lean_ctor_set(x_177, 2, x_3);
-lean_ctor_set(x_177, 3, x_4);
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_57);
-return x_177;
+x_188 = 1;
+x_189 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_189, 0, x_1);
+lean_ctor_set(x_189, 1, x_2);
+lean_ctor_set(x_189, 2, x_3);
+lean_ctor_set(x_189, 3, x_4);
+lean_ctor_set_uint8(x_189, sizeof(void*)*4, x_188);
+return x_189;
 }
 }
 else
 {
-uint8_t x_178; 
-x_178 = lean_ctor_get_uint8(x_171, sizeof(void*)*4);
-if (x_178 == 0)
+uint8_t x_190; 
+x_190 = lean_ctor_get_uint8(x_181, sizeof(void*)*4);
+if (x_190 == 0)
 {
-uint8_t x_179; 
-x_179 = !lean_is_exclusive(x_4);
-if (x_179 == 0)
+uint8_t x_191; 
+x_191 = !lean_is_exclusive(x_4);
+if (x_191 == 0)
 {
-lean_object* x_180; lean_object* x_181; uint8_t x_182; 
-x_180 = lean_ctor_get(x_4, 3);
-lean_dec(x_180);
-x_181 = lean_ctor_get(x_4, 0);
-lean_dec(x_181);
-x_182 = !lean_is_exclusive(x_171);
-if (x_182 == 0)
+lean_object* x_192; lean_object* x_193; uint8_t x_194; 
+x_192 = lean_ctor_get(x_4, 3);
+lean_dec(x_192);
+x_193 = lean_ctor_get(x_4, 0);
+lean_dec(x_193);
+x_194 = !lean_is_exclusive(x_181);
+if (x_194 == 0)
 {
-lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; uint8_t x_187; 
-x_183 = lean_ctor_get(x_171, 0);
-x_184 = lean_ctor_get(x_171, 1);
-x_185 = lean_ctor_get(x_171, 2);
-x_186 = lean_ctor_get(x_171, 3);
+lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; uint8_t x_199; uint8_t x_200; 
+x_195 = lean_ctor_get(x_181, 0);
+x_196 = lean_ctor_get(x_181, 1);
+x_197 = lean_ctor_get(x_181, 2);
+x_198 = lean_ctor_get(x_181, 3);
+x_199 = 1;
 lean_inc(x_8);
-lean_ctor_set(x_171, 3, x_8);
-lean_ctor_set(x_171, 2, x_3);
-lean_ctor_set(x_171, 1, x_2);
-lean_ctor_set(x_171, 0, x_1);
-x_187 = !lean_is_exclusive(x_8);
-if (x_187 == 0)
+lean_ctor_set(x_181, 3, x_8);
+lean_ctor_set(x_181, 2, x_3);
+lean_ctor_set(x_181, 1, x_2);
+lean_ctor_set(x_181, 0, x_1);
+x_200 = !lean_is_exclusive(x_8);
+if (x_200 == 0)
 {
-lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; 
-x_188 = lean_ctor_get(x_8, 3);
-lean_dec(x_188);
-x_189 = lean_ctor_get(x_8, 2);
-lean_dec(x_189);
-x_190 = lean_ctor_get(x_8, 1);
-lean_dec(x_190);
-x_191 = lean_ctor_get(x_8, 0);
-lean_dec(x_191);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_57);
-lean_ctor_set(x_8, 3, x_186);
-lean_ctor_set(x_8, 2, x_185);
-lean_ctor_set(x_8, 1, x_184);
-lean_ctor_set(x_8, 0, x_183);
+lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; uint8_t x_205; 
+x_201 = lean_ctor_get(x_8, 3);
+lean_dec(x_201);
+x_202 = lean_ctor_get(x_8, 2);
+lean_dec(x_202);
+x_203 = lean_ctor_get(x_8, 1);
+lean_dec(x_203);
+x_204 = lean_ctor_get(x_8, 0);
+lean_dec(x_204);
+lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_199);
+lean_ctor_set(x_8, 3, x_198);
+lean_ctor_set(x_8, 2, x_197);
+lean_ctor_set(x_8, 1, x_196);
+lean_ctor_set(x_8, 0, x_195);
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_199);
+x_205 = 0;
 lean_ctor_set(x_4, 3, x_8);
-lean_ctor_set(x_4, 0, x_171);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_178);
+lean_ctor_set(x_4, 0, x_181);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_205);
 return x_4;
 }
 else
 {
-lean_object* x_192; 
+lean_object* x_206; uint8_t x_207; 
 lean_dec(x_8);
-lean_ctor_set_uint8(x_171, sizeof(void*)*4, x_57);
-x_192 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_192, 0, x_183);
-lean_ctor_set(x_192, 1, x_184);
-lean_ctor_set(x_192, 2, x_185);
-lean_ctor_set(x_192, 3, x_186);
-lean_ctor_set_uint8(x_192, sizeof(void*)*4, x_57);
-lean_ctor_set(x_4, 3, x_192);
-lean_ctor_set(x_4, 0, x_171);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_178);
+lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_199);
+x_206 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_206, 0, x_195);
+lean_ctor_set(x_206, 1, x_196);
+lean_ctor_set(x_206, 2, x_197);
+lean_ctor_set(x_206, 3, x_198);
+lean_ctor_set_uint8(x_206, sizeof(void*)*4, x_199);
+x_207 = 0;
+lean_ctor_set(x_4, 3, x_206);
+lean_ctor_set(x_4, 0, x_181);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_207);
 return x_4;
 }
 }
 else
 {
-lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; 
-x_193 = lean_ctor_get(x_171, 0);
-x_194 = lean_ctor_get(x_171, 1);
-x_195 = lean_ctor_get(x_171, 2);
-x_196 = lean_ctor_get(x_171, 3);
-lean_inc(x_196);
-lean_inc(x_195);
-lean_inc(x_194);
-lean_inc(x_193);
-lean_dec(x_171);
+lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; uint8_t x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; uint8_t x_216; 
+x_208 = lean_ctor_get(x_181, 0);
+x_209 = lean_ctor_get(x_181, 1);
+x_210 = lean_ctor_get(x_181, 2);
+x_211 = lean_ctor_get(x_181, 3);
+lean_inc(x_211);
+lean_inc(x_210);
+lean_inc(x_209);
+lean_inc(x_208);
+lean_dec(x_181);
+x_212 = 1;
 lean_inc(x_8);
-x_197 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_197, 0, x_1);
-lean_ctor_set(x_197, 1, x_2);
-lean_ctor_set(x_197, 2, x_3);
-lean_ctor_set(x_197, 3, x_8);
+x_213 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_213, 0, x_1);
+lean_ctor_set(x_213, 1, x_2);
+lean_ctor_set(x_213, 2, x_3);
+lean_ctor_set(x_213, 3, x_8);
 if (lean_is_exclusive(x_8)) {
  lean_ctor_release(x_8, 0);
  lean_ctor_release(x_8, 1);
  lean_ctor_release(x_8, 2);
  lean_ctor_release(x_8, 3);
- x_198 = x_8;
+ x_214 = x_8;
 } else {
  lean_dec_ref(x_8);
- x_198 = lean_box(0);
+ x_214 = lean_box(0);
 }
-lean_ctor_set_uint8(x_197, sizeof(void*)*4, x_57);
-if (lean_is_scalar(x_198)) {
- x_199 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set_uint8(x_213, sizeof(void*)*4, x_212);
+if (lean_is_scalar(x_214)) {
+ x_215 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_199 = x_198;
+ x_215 = x_214;
 }
-lean_ctor_set(x_199, 0, x_193);
-lean_ctor_set(x_199, 1, x_194);
-lean_ctor_set(x_199, 2, x_195);
-lean_ctor_set(x_199, 3, x_196);
-lean_ctor_set_uint8(x_199, sizeof(void*)*4, x_57);
-lean_ctor_set(x_4, 3, x_199);
-lean_ctor_set(x_4, 0, x_197);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_178);
+lean_ctor_set(x_215, 0, x_208);
+lean_ctor_set(x_215, 1, x_209);
+lean_ctor_set(x_215, 2, x_210);
+lean_ctor_set(x_215, 3, x_211);
+lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_212);
+x_216 = 0;
+lean_ctor_set(x_4, 3, x_215);
+lean_ctor_set(x_4, 0, x_213);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_216);
 return x_4;
 }
 }
 else
 {
-lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; 
-x_200 = lean_ctor_get(x_4, 1);
-x_201 = lean_ctor_get(x_4, 2);
-lean_inc(x_201);
-lean_inc(x_200);
-lean_dec(x_4);
-x_202 = lean_ctor_get(x_171, 0);
-lean_inc(x_202);
-x_203 = lean_ctor_get(x_171, 1);
-lean_inc(x_203);
-x_204 = lean_ctor_get(x_171, 2);
-lean_inc(x_204);
-x_205 = lean_ctor_get(x_171, 3);
-lean_inc(x_205);
-if (lean_is_exclusive(x_171)) {
- lean_ctor_release(x_171, 0);
- lean_ctor_release(x_171, 1);
- lean_ctor_release(x_171, 2);
- lean_ctor_release(x_171, 3);
- x_206 = x_171;
-} else {
- lean_dec_ref(x_171);
- x_206 = lean_box(0);
-}
-lean_inc(x_8);
-if (lean_is_scalar(x_206)) {
- x_207 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_207 = x_206;
-}
-lean_ctor_set(x_207, 0, x_1);
-lean_ctor_set(x_207, 1, x_2);
-lean_ctor_set(x_207, 2, x_3);
-lean_ctor_set(x_207, 3, x_8);
-if (lean_is_exclusive(x_8)) {
- lean_ctor_release(x_8, 0);
- lean_ctor_release(x_8, 1);
- lean_ctor_release(x_8, 2);
- lean_ctor_release(x_8, 3);
- x_208 = x_8;
-} else {
- lean_dec_ref(x_8);
- x_208 = lean_box(0);
-}
-lean_ctor_set_uint8(x_207, sizeof(void*)*4, x_57);
-if (lean_is_scalar(x_208)) {
- x_209 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_209 = x_208;
-}
-lean_ctor_set(x_209, 0, x_202);
-lean_ctor_set(x_209, 1, x_203);
-lean_ctor_set(x_209, 2, x_204);
-lean_ctor_set(x_209, 3, x_205);
-lean_ctor_set_uint8(x_209, sizeof(void*)*4, x_57);
-x_210 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_210, 0, x_207);
-lean_ctor_set(x_210, 1, x_200);
-lean_ctor_set(x_210, 2, x_201);
-lean_ctor_set(x_210, 3, x_209);
-lean_ctor_set_uint8(x_210, sizeof(void*)*4, x_178);
-return x_210;
-}
-}
-else
-{
-uint8_t x_211; 
-x_211 = !lean_is_exclusive(x_4);
-if (x_211 == 0)
-{
-lean_object* x_212; lean_object* x_213; uint8_t x_214; 
-x_212 = lean_ctor_get(x_4, 3);
-lean_dec(x_212);
-x_213 = lean_ctor_get(x_4, 0);
-lean_dec(x_213);
-x_214 = !lean_is_exclusive(x_8);
-if (x_214 == 0)
-{
-lean_object* x_215; 
-lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_178);
-x_215 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_215, 0, x_1);
-lean_ctor_set(x_215, 1, x_2);
-lean_ctor_set(x_215, 2, x_3);
-lean_ctor_set(x_215, 3, x_4);
-lean_ctor_set_uint8(x_215, sizeof(void*)*4, x_178);
-return x_215;
-}
-else
-{
-lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; 
-x_216 = lean_ctor_get(x_8, 0);
-x_217 = lean_ctor_get(x_8, 1);
-x_218 = lean_ctor_get(x_8, 2);
-x_219 = lean_ctor_get(x_8, 3);
-lean_inc(x_219);
+lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; uint8_t x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; uint8_t x_228; lean_object* x_229; 
+x_217 = lean_ctor_get(x_4, 1);
+x_218 = lean_ctor_get(x_4, 2);
 lean_inc(x_218);
 lean_inc(x_217);
-lean_inc(x_216);
-lean_dec(x_8);
-x_220 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_220, 0, x_216);
-lean_ctor_set(x_220, 1, x_217);
-lean_ctor_set(x_220, 2, x_218);
-lean_ctor_set(x_220, 3, x_219);
-lean_ctor_set_uint8(x_220, sizeof(void*)*4, x_178);
-lean_ctor_set(x_4, 0, x_220);
-x_221 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_221, 0, x_1);
-lean_ctor_set(x_221, 1, x_2);
-lean_ctor_set(x_221, 2, x_3);
-lean_ctor_set(x_221, 3, x_4);
-lean_ctor_set_uint8(x_221, sizeof(void*)*4, x_178);
-return x_221;
-}
-}
-else
-{
-lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; 
-x_222 = lean_ctor_get(x_4, 1);
-x_223 = lean_ctor_get(x_4, 2);
-lean_inc(x_223);
-lean_inc(x_222);
 lean_dec(x_4);
-x_224 = lean_ctor_get(x_8, 0);
-lean_inc(x_224);
-x_225 = lean_ctor_get(x_8, 1);
-lean_inc(x_225);
-x_226 = lean_ctor_get(x_8, 2);
-lean_inc(x_226);
-x_227 = lean_ctor_get(x_8, 3);
-lean_inc(x_227);
+x_219 = lean_ctor_get(x_181, 0);
+lean_inc(x_219);
+x_220 = lean_ctor_get(x_181, 1);
+lean_inc(x_220);
+x_221 = lean_ctor_get(x_181, 2);
+lean_inc(x_221);
+x_222 = lean_ctor_get(x_181, 3);
+lean_inc(x_222);
+if (lean_is_exclusive(x_181)) {
+ lean_ctor_release(x_181, 0);
+ lean_ctor_release(x_181, 1);
+ lean_ctor_release(x_181, 2);
+ lean_ctor_release(x_181, 3);
+ x_223 = x_181;
+} else {
+ lean_dec_ref(x_181);
+ x_223 = lean_box(0);
+}
+x_224 = 1;
+lean_inc(x_8);
+if (lean_is_scalar(x_223)) {
+ x_225 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_225 = x_223;
+}
+lean_ctor_set(x_225, 0, x_1);
+lean_ctor_set(x_225, 1, x_2);
+lean_ctor_set(x_225, 2, x_3);
+lean_ctor_set(x_225, 3, x_8);
 if (lean_is_exclusive(x_8)) {
  lean_ctor_release(x_8, 0);
  lean_ctor_release(x_8, 1);
  lean_ctor_release(x_8, 2);
  lean_ctor_release(x_8, 3);
- x_228 = x_8;
+ x_226 = x_8;
 } else {
  lean_dec_ref(x_8);
- x_228 = lean_box(0);
+ x_226 = lean_box(0);
 }
-if (lean_is_scalar(x_228)) {
- x_229 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set_uint8(x_225, sizeof(void*)*4, x_224);
+if (lean_is_scalar(x_226)) {
+ x_227 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_229 = x_228;
+ x_227 = x_226;
 }
-lean_ctor_set(x_229, 0, x_224);
-lean_ctor_set(x_229, 1, x_225);
-lean_ctor_set(x_229, 2, x_226);
+lean_ctor_set(x_227, 0, x_219);
+lean_ctor_set(x_227, 1, x_220);
+lean_ctor_set(x_227, 2, x_221);
+lean_ctor_set(x_227, 3, x_222);
+lean_ctor_set_uint8(x_227, sizeof(void*)*4, x_224);
+x_228 = 0;
+x_229 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_229, 0, x_225);
+lean_ctor_set(x_229, 1, x_217);
+lean_ctor_set(x_229, 2, x_218);
 lean_ctor_set(x_229, 3, x_227);
-lean_ctor_set_uint8(x_229, sizeof(void*)*4, x_178);
-x_230 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_230, 0, x_229);
-lean_ctor_set(x_230, 1, x_222);
-lean_ctor_set(x_230, 2, x_223);
-lean_ctor_set(x_230, 3, x_171);
-lean_ctor_set_uint8(x_230, sizeof(void*)*4, x_7);
-x_231 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_231, 0, x_1);
-lean_ctor_set(x_231, 1, x_2);
-lean_ctor_set(x_231, 2, x_3);
-lean_ctor_set(x_231, 3, x_230);
-lean_ctor_set_uint8(x_231, sizeof(void*)*4, x_178);
-return x_231;
+lean_ctor_set_uint8(x_229, sizeof(void*)*4, x_228);
+return x_229;
+}
+}
+else
+{
+uint8_t x_230; 
+lean_dec(x_8);
+x_230 = !lean_is_exclusive(x_181);
+if (x_230 == 0)
+{
+lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; uint8_t x_235; 
+x_231 = lean_ctor_get(x_181, 3);
+lean_dec(x_231);
+x_232 = lean_ctor_get(x_181, 2);
+lean_dec(x_232);
+x_233 = lean_ctor_get(x_181, 1);
+lean_dec(x_233);
+x_234 = lean_ctor_get(x_181, 0);
+lean_dec(x_234);
+x_235 = 1;
+lean_ctor_set(x_181, 3, x_4);
+lean_ctor_set(x_181, 2, x_3);
+lean_ctor_set(x_181, 1, x_2);
+lean_ctor_set(x_181, 0, x_1);
+lean_ctor_set_uint8(x_181, sizeof(void*)*4, x_235);
+return x_181;
+}
+else
+{
+uint8_t x_236; lean_object* x_237; 
+lean_dec(x_181);
+x_236 = 1;
+x_237 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_237, 0, x_1);
+lean_ctor_set(x_237, 1, x_2);
+lean_ctor_set(x_237, 2, x_3);
+lean_ctor_set(x_237, 3, x_4);
+lean_ctor_set_uint8(x_237, sizeof(void*)*4, x_236);
+return x_237;
 }
 }
 }
@@ -5991,4840 +7542,4337 @@ return x_231;
 }
 else
 {
-lean_object* x_232; 
-x_232 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_232, 0, x_1);
-lean_ctor_set(x_232, 1, x_2);
-lean_ctor_set(x_232, 2, x_3);
-lean_ctor_set(x_232, 3, x_4);
-lean_ctor_set_uint8(x_232, sizeof(void*)*4, x_7);
-return x_232;
+uint8_t x_238; lean_object* x_239; 
+x_238 = 1;
+x_239 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_239, 0, x_1);
+lean_ctor_set(x_239, 1, x_2);
+lean_ctor_set(x_239, 2, x_3);
+lean_ctor_set(x_239, 3, x_4);
+lean_ctor_set_uint8(x_239, sizeof(void*)*4, x_238);
+return x_239;
 }
 }
 }
 else
 {
-uint8_t x_233; 
-x_233 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_233 == 0)
+uint8_t x_240; 
+x_240 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_240 == 0)
 {
-lean_object* x_234; 
-x_234 = lean_ctor_get(x_1, 0);
-lean_inc(x_234);
-if (lean_obj_tag(x_234) == 0)
+lean_object* x_241; 
+x_241 = lean_ctor_get(x_1, 0);
+lean_inc(x_241);
+if (lean_obj_tag(x_241) == 0)
 {
-lean_object* x_235; 
-x_235 = lean_ctor_get(x_1, 3);
-lean_inc(x_235);
-if (lean_obj_tag(x_235) == 0)
+lean_object* x_242; 
+x_242 = lean_ctor_get(x_1, 3);
+lean_inc(x_242);
+if (lean_obj_tag(x_242) == 0)
 {
+uint8_t x_243; 
+x_243 = !lean_is_exclusive(x_1);
+if (x_243 == 0)
+{
+lean_object* x_244; lean_object* x_245; 
+x_244 = lean_ctor_get(x_1, 3);
+lean_dec(x_244);
+x_245 = lean_ctor_get(x_1, 0);
+lean_dec(x_245);
+lean_ctor_set(x_1, 0, x_242);
 if (lean_obj_tag(x_4) == 0)
 {
-uint8_t x_236; 
-x_236 = !lean_is_exclusive(x_1);
-if (x_236 == 0)
-{
-lean_object* x_237; lean_object* x_238; uint8_t x_239; lean_object* x_240; 
-x_237 = lean_ctor_get(x_1, 3);
-lean_dec(x_237);
-x_238 = lean_ctor_get(x_1, 0);
-lean_dec(x_238);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 0, x_4);
-x_239 = 1;
-x_240 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_240, 0, x_1);
-lean_ctor_set(x_240, 1, x_2);
-lean_ctor_set(x_240, 2, x_3);
-lean_ctor_set(x_240, 3, x_4);
-lean_ctor_set_uint8(x_240, sizeof(void*)*4, x_239);
-return x_240;
+uint8_t x_246; lean_object* x_247; 
+x_246 = 1;
+x_247 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_247, 0, x_1);
+lean_ctor_set(x_247, 1, x_2);
+lean_ctor_set(x_247, 2, x_3);
+lean_ctor_set(x_247, 3, x_4);
+lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
+return x_247;
 }
 else
 {
-lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; lean_object* x_245; 
-x_241 = lean_ctor_get(x_1, 1);
-x_242 = lean_ctor_get(x_1, 2);
-lean_inc(x_242);
-lean_inc(x_241);
-lean_dec(x_1);
-x_243 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_243, 0, x_4);
-lean_ctor_set(x_243, 1, x_241);
-lean_ctor_set(x_243, 2, x_242);
-lean_ctor_set(x_243, 3, x_4);
-lean_ctor_set_uint8(x_243, sizeof(void*)*4, x_233);
-x_244 = 1;
-x_245 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_245, 0, x_243);
-lean_ctor_set(x_245, 1, x_2);
-lean_ctor_set(x_245, 2, x_3);
-lean_ctor_set(x_245, 3, x_4);
-lean_ctor_set_uint8(x_245, sizeof(void*)*4, x_244);
-return x_245;
-}
+uint8_t x_248; 
+x_248 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_248 == 0)
+{
+lean_object* x_249; 
+x_249 = lean_ctor_get(x_4, 0);
+lean_inc(x_249);
+if (lean_obj_tag(x_249) == 0)
+{
+lean_object* x_250; 
+x_250 = lean_ctor_get(x_4, 3);
+lean_inc(x_250);
+if (lean_obj_tag(x_250) == 0)
+{
+uint8_t x_251; lean_object* x_252; 
+x_251 = 1;
+x_252 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_252, 0, x_1);
+lean_ctor_set(x_252, 1, x_2);
+lean_ctor_set(x_252, 2, x_3);
+lean_ctor_set(x_252, 3, x_4);
+lean_ctor_set_uint8(x_252, sizeof(void*)*4, x_251);
+return x_252;
 }
 else
 {
-uint8_t x_246; 
-x_246 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
-if (x_246 == 0)
+uint8_t x_253; 
+x_253 = lean_ctor_get_uint8(x_250, sizeof(void*)*4);
+if (x_253 == 0)
 {
-lean_object* x_247; 
-x_247 = lean_ctor_get(x_4, 0);
-lean_inc(x_247);
-if (lean_obj_tag(x_247) == 0)
-{
-lean_object* x_248; 
-x_248 = lean_ctor_get(x_4, 3);
-lean_inc(x_248);
-if (lean_obj_tag(x_248) == 0)
-{
-uint8_t x_249; 
-x_249 = !lean_is_exclusive(x_1);
-if (x_249 == 0)
-{
-lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; uint8_t x_254; 
-x_250 = lean_ctor_get(x_1, 1);
-x_251 = lean_ctor_get(x_1, 2);
-x_252 = lean_ctor_get(x_1, 3);
-lean_dec(x_252);
-x_253 = lean_ctor_get(x_1, 0);
-lean_dec(x_253);
+uint8_t x_254; 
 x_254 = !lean_is_exclusive(x_4);
 if (x_254 == 0)
 {
-lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; uint8_t x_259; lean_object* x_260; 
+lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; uint8_t x_259; 
 x_255 = lean_ctor_get(x_4, 1);
 x_256 = lean_ctor_get(x_4, 2);
 x_257 = lean_ctor_get(x_4, 3);
 lean_dec(x_257);
 x_258 = lean_ctor_get(x_4, 0);
 lean_dec(x_258);
-lean_ctor_set(x_4, 2, x_251);
-lean_ctor_set(x_4, 1, x_250);
-lean_ctor_set(x_4, 0, x_248);
-lean_ctor_set(x_1, 3, x_248);
-lean_ctor_set(x_1, 2, x_256);
-lean_ctor_set(x_1, 1, x_255);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_246);
-x_259 = 1;
-x_260 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_260, 0, x_4);
-lean_ctor_set(x_260, 1, x_2);
-lean_ctor_set(x_260, 2, x_3);
-lean_ctor_set(x_260, 3, x_1);
-lean_ctor_set_uint8(x_260, sizeof(void*)*4, x_259);
-return x_260;
-}
-else
+x_259 = !lean_is_exclusive(x_250);
+if (x_259 == 0)
 {
-lean_object* x_261; lean_object* x_262; lean_object* x_263; uint8_t x_264; lean_object* x_265; 
-x_261 = lean_ctor_get(x_4, 1);
-x_262 = lean_ctor_get(x_4, 2);
-lean_inc(x_262);
-lean_inc(x_261);
-lean_dec(x_4);
-x_263 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_263, 0, x_248);
-lean_ctor_set(x_263, 1, x_250);
-lean_ctor_set(x_263, 2, x_251);
-lean_ctor_set(x_263, 3, x_248);
-lean_ctor_set_uint8(x_263, sizeof(void*)*4, x_246);
-lean_ctor_set(x_1, 3, x_248);
-lean_ctor_set(x_1, 2, x_262);
-lean_ctor_set(x_1, 1, x_261);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_246);
+lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; uint8_t x_264; uint8_t x_265; lean_object* x_266; 
+x_260 = lean_ctor_get(x_250, 0);
+x_261 = lean_ctor_get(x_250, 1);
+x_262 = lean_ctor_get(x_250, 2);
+x_263 = lean_ctor_get(x_250, 3);
 x_264 = 1;
-x_265 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_265, 0, x_263);
-lean_ctor_set(x_265, 1, x_2);
-lean_ctor_set(x_265, 2, x_3);
-lean_ctor_set(x_265, 3, x_1);
-lean_ctor_set_uint8(x_265, sizeof(void*)*4, x_264);
-return x_265;
-}
+lean_ctor_set(x_250, 3, x_249);
+lean_ctor_set(x_250, 2, x_3);
+lean_ctor_set(x_250, 1, x_2);
+lean_ctor_set(x_250, 0, x_1);
+lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_264);
+lean_ctor_set(x_4, 3, x_263);
+lean_ctor_set(x_4, 2, x_262);
+lean_ctor_set(x_4, 1, x_261);
+lean_ctor_set(x_4, 0, x_260);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_264);
+x_265 = 0;
+x_266 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_266, 0, x_250);
+lean_ctor_set(x_266, 1, x_255);
+lean_ctor_set(x_266, 2, x_256);
+lean_ctor_set(x_266, 3, x_4);
+lean_ctor_set_uint8(x_266, sizeof(void*)*4, x_265);
+return x_266;
 }
 else
 {
-lean_object* x_266; lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; 
-x_266 = lean_ctor_get(x_1, 1);
-x_267 = lean_ctor_get(x_1, 2);
-lean_inc(x_267);
-lean_inc(x_266);
-lean_dec(x_1);
-x_268 = lean_ctor_get(x_4, 1);
-lean_inc(x_268);
-x_269 = lean_ctor_get(x_4, 2);
+lean_object* x_267; lean_object* x_268; lean_object* x_269; lean_object* x_270; uint8_t x_271; lean_object* x_272; uint8_t x_273; lean_object* x_274; 
+x_267 = lean_ctor_get(x_250, 0);
+x_268 = lean_ctor_get(x_250, 1);
+x_269 = lean_ctor_get(x_250, 2);
+x_270 = lean_ctor_get(x_250, 3);
+lean_inc(x_270);
 lean_inc(x_269);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_270 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_270 = lean_box(0);
-}
-if (lean_is_scalar(x_270)) {
- x_271 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_271 = x_270;
-}
-lean_ctor_set(x_271, 0, x_248);
-lean_ctor_set(x_271, 1, x_266);
-lean_ctor_set(x_271, 2, x_267);
-lean_ctor_set(x_271, 3, x_248);
-lean_ctor_set_uint8(x_271, sizeof(void*)*4, x_246);
+lean_inc(x_268);
+lean_inc(x_267);
+lean_dec(x_250);
+x_271 = 1;
 x_272 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_272, 0, x_248);
-lean_ctor_set(x_272, 1, x_268);
-lean_ctor_set(x_272, 2, x_269);
-lean_ctor_set(x_272, 3, x_248);
-lean_ctor_set_uint8(x_272, sizeof(void*)*4, x_246);
-x_273 = 1;
+lean_ctor_set(x_272, 0, x_1);
+lean_ctor_set(x_272, 1, x_2);
+lean_ctor_set(x_272, 2, x_3);
+lean_ctor_set(x_272, 3, x_249);
+lean_ctor_set_uint8(x_272, sizeof(void*)*4, x_271);
+lean_ctor_set(x_4, 3, x_270);
+lean_ctor_set(x_4, 2, x_269);
+lean_ctor_set(x_4, 1, x_268);
+lean_ctor_set(x_4, 0, x_267);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_271);
+x_273 = 0;
 x_274 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_274, 0, x_271);
-lean_ctor_set(x_274, 1, x_2);
-lean_ctor_set(x_274, 2, x_3);
-lean_ctor_set(x_274, 3, x_272);
+lean_ctor_set(x_274, 0, x_272);
+lean_ctor_set(x_274, 1, x_255);
+lean_ctor_set(x_274, 2, x_256);
+lean_ctor_set(x_274, 3, x_4);
 lean_ctor_set_uint8(x_274, sizeof(void*)*4, x_273);
 return x_274;
 }
 }
 else
 {
-uint8_t x_275; 
-x_275 = lean_ctor_get_uint8(x_248, sizeof(void*)*4);
-if (x_275 == 0)
-{
-uint8_t x_276; 
-x_276 = !lean_is_exclusive(x_1);
-if (x_276 == 0)
-{
-lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; uint8_t x_281; 
-x_277 = lean_ctor_get(x_1, 1);
-x_278 = lean_ctor_get(x_1, 2);
-x_279 = lean_ctor_get(x_1, 3);
-lean_dec(x_279);
-x_280 = lean_ctor_get(x_1, 0);
-lean_dec(x_280);
-x_281 = !lean_is_exclusive(x_4);
-if (x_281 == 0)
-{
-lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; uint8_t x_286; 
-x_282 = lean_ctor_get(x_4, 1);
-x_283 = lean_ctor_get(x_4, 2);
-x_284 = lean_ctor_get(x_4, 3);
-lean_dec(x_284);
-x_285 = lean_ctor_get(x_4, 0);
-lean_dec(x_285);
-x_286 = !lean_is_exclusive(x_248);
-if (x_286 == 0)
-{
-lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; uint8_t x_291; lean_object* x_292; 
-x_287 = lean_ctor_get(x_248, 0);
-x_288 = lean_ctor_get(x_248, 1);
-x_289 = lean_ctor_get(x_248, 2);
-x_290 = lean_ctor_get(x_248, 3);
-lean_ctor_set(x_248, 3, x_247);
-lean_ctor_set(x_248, 2, x_278);
-lean_ctor_set(x_248, 1, x_277);
-lean_ctor_set(x_248, 0, x_247);
-x_291 = 1;
-lean_ctor_set(x_4, 3, x_247);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_248);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_291);
-lean_ctor_set(x_1, 3, x_290);
-lean_ctor_set(x_1, 2, x_289);
-lean_ctor_set(x_1, 1, x_288);
-lean_ctor_set(x_1, 0, x_287);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_291);
-x_292 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_292, 0, x_4);
-lean_ctor_set(x_292, 1, x_282);
-lean_ctor_set(x_292, 2, x_283);
-lean_ctor_set(x_292, 3, x_1);
-lean_ctor_set_uint8(x_292, sizeof(void*)*4, x_275);
-return x_292;
+lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; uint8_t x_282; lean_object* x_283; lean_object* x_284; uint8_t x_285; lean_object* x_286; 
+x_275 = lean_ctor_get(x_4, 1);
+x_276 = lean_ctor_get(x_4, 2);
+lean_inc(x_276);
+lean_inc(x_275);
+lean_dec(x_4);
+x_277 = lean_ctor_get(x_250, 0);
+lean_inc(x_277);
+x_278 = lean_ctor_get(x_250, 1);
+lean_inc(x_278);
+x_279 = lean_ctor_get(x_250, 2);
+lean_inc(x_279);
+x_280 = lean_ctor_get(x_250, 3);
+lean_inc(x_280);
+if (lean_is_exclusive(x_250)) {
+ lean_ctor_release(x_250, 0);
+ lean_ctor_release(x_250, 1);
+ lean_ctor_release(x_250, 2);
+ lean_ctor_release(x_250, 3);
+ x_281 = x_250;
+} else {
+ lean_dec_ref(x_250);
+ x_281 = lean_box(0);
+}
+x_282 = 1;
+if (lean_is_scalar(x_281)) {
+ x_283 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_283 = x_281;
+}
+lean_ctor_set(x_283, 0, x_1);
+lean_ctor_set(x_283, 1, x_2);
+lean_ctor_set(x_283, 2, x_3);
+lean_ctor_set(x_283, 3, x_249);
+lean_ctor_set_uint8(x_283, sizeof(void*)*4, x_282);
+x_284 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_284, 0, x_277);
+lean_ctor_set(x_284, 1, x_278);
+lean_ctor_set(x_284, 2, x_279);
+lean_ctor_set(x_284, 3, x_280);
+lean_ctor_set_uint8(x_284, sizeof(void*)*4, x_282);
+x_285 = 0;
+x_286 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_286, 0, x_283);
+lean_ctor_set(x_286, 1, x_275);
+lean_ctor_set(x_286, 2, x_276);
+lean_ctor_set(x_286, 3, x_284);
+lean_ctor_set_uint8(x_286, sizeof(void*)*4, x_285);
+return x_286;
+}
 }
 else
 {
-lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; uint8_t x_298; lean_object* x_299; 
-x_293 = lean_ctor_get(x_248, 0);
-x_294 = lean_ctor_get(x_248, 1);
-x_295 = lean_ctor_get(x_248, 2);
-x_296 = lean_ctor_get(x_248, 3);
+uint8_t x_287; 
+x_287 = !lean_is_exclusive(x_250);
+if (x_287 == 0)
+{
+lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; uint8_t x_292; 
+x_288 = lean_ctor_get(x_250, 3);
+lean_dec(x_288);
+x_289 = lean_ctor_get(x_250, 2);
+lean_dec(x_289);
+x_290 = lean_ctor_get(x_250, 1);
+lean_dec(x_290);
+x_291 = lean_ctor_get(x_250, 0);
+lean_dec(x_291);
+x_292 = 1;
+lean_ctor_set(x_250, 3, x_4);
+lean_ctor_set(x_250, 2, x_3);
+lean_ctor_set(x_250, 1, x_2);
+lean_ctor_set(x_250, 0, x_1);
+lean_ctor_set_uint8(x_250, sizeof(void*)*4, x_292);
+return x_250;
+}
+else
+{
+uint8_t x_293; lean_object* x_294; 
+lean_dec(x_250);
+x_293 = 1;
+x_294 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_294, 0, x_1);
+lean_ctor_set(x_294, 1, x_2);
+lean_ctor_set(x_294, 2, x_3);
+lean_ctor_set(x_294, 3, x_4);
+lean_ctor_set_uint8(x_294, sizeof(void*)*4, x_293);
+return x_294;
+}
+}
+}
+}
+else
+{
+uint8_t x_295; 
+x_295 = lean_ctor_get_uint8(x_249, sizeof(void*)*4);
+if (x_295 == 0)
+{
+lean_object* x_296; 
+x_296 = lean_ctor_get(x_4, 3);
 lean_inc(x_296);
-lean_inc(x_295);
-lean_inc(x_294);
-lean_inc(x_293);
-lean_dec(x_248);
-x_297 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_297, 0, x_247);
-lean_ctor_set(x_297, 1, x_277);
-lean_ctor_set(x_297, 2, x_278);
-lean_ctor_set(x_297, 3, x_247);
-lean_ctor_set_uint8(x_297, sizeof(void*)*4, x_275);
-x_298 = 1;
-lean_ctor_set(x_4, 3, x_247);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_297);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_298);
-lean_ctor_set(x_1, 3, x_296);
-lean_ctor_set(x_1, 2, x_295);
-lean_ctor_set(x_1, 1, x_294);
-lean_ctor_set(x_1, 0, x_293);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_298);
-x_299 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_299, 0, x_4);
-lean_ctor_set(x_299, 1, x_282);
-lean_ctor_set(x_299, 2, x_283);
-lean_ctor_set(x_299, 3, x_1);
-lean_ctor_set_uint8(x_299, sizeof(void*)*4, x_275);
-return x_299;
-}
+if (lean_obj_tag(x_296) == 0)
+{
+uint8_t x_297; 
+x_297 = !lean_is_exclusive(x_4);
+if (x_297 == 0)
+{
+lean_object* x_298; lean_object* x_299; uint8_t x_300; 
+x_298 = lean_ctor_get(x_4, 3);
+lean_dec(x_298);
+x_299 = lean_ctor_get(x_4, 0);
+lean_dec(x_299);
+x_300 = !lean_is_exclusive(x_249);
+if (x_300 == 0)
+{
+lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; uint8_t x_305; uint8_t x_306; lean_object* x_307; 
+x_301 = lean_ctor_get(x_249, 0);
+x_302 = lean_ctor_get(x_249, 1);
+x_303 = lean_ctor_get(x_249, 2);
+x_304 = lean_ctor_get(x_249, 3);
+x_305 = 1;
+lean_ctor_set(x_249, 3, x_301);
+lean_ctor_set(x_249, 2, x_3);
+lean_ctor_set(x_249, 1, x_2);
+lean_ctor_set(x_249, 0, x_1);
+lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_305);
+lean_ctor_set(x_4, 0, x_304);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_305);
+x_306 = 0;
+x_307 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_307, 0, x_249);
+lean_ctor_set(x_307, 1, x_302);
+lean_ctor_set(x_307, 2, x_303);
+lean_ctor_set(x_307, 3, x_4);
+lean_ctor_set_uint8(x_307, sizeof(void*)*4, x_306);
+return x_307;
 }
 else
 {
-lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; uint8_t x_308; lean_object* x_309; lean_object* x_310; 
-x_300 = lean_ctor_get(x_4, 1);
-x_301 = lean_ctor_get(x_4, 2);
-lean_inc(x_301);
-lean_inc(x_300);
-lean_dec(x_4);
-x_302 = lean_ctor_get(x_248, 0);
-lean_inc(x_302);
-x_303 = lean_ctor_get(x_248, 1);
-lean_inc(x_303);
-x_304 = lean_ctor_get(x_248, 2);
-lean_inc(x_304);
-x_305 = lean_ctor_get(x_248, 3);
-lean_inc(x_305);
-if (lean_is_exclusive(x_248)) {
- lean_ctor_release(x_248, 0);
- lean_ctor_release(x_248, 1);
- lean_ctor_release(x_248, 2);
- lean_ctor_release(x_248, 3);
- x_306 = x_248;
-} else {
- lean_dec_ref(x_248);
- x_306 = lean_box(0);
-}
-if (lean_is_scalar(x_306)) {
- x_307 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_307 = x_306;
-}
-lean_ctor_set(x_307, 0, x_247);
-lean_ctor_set(x_307, 1, x_277);
-lean_ctor_set(x_307, 2, x_278);
-lean_ctor_set(x_307, 3, x_247);
-lean_ctor_set_uint8(x_307, sizeof(void*)*4, x_275);
-x_308 = 1;
-x_309 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_309, 0, x_307);
-lean_ctor_set(x_309, 1, x_2);
-lean_ctor_set(x_309, 2, x_3);
-lean_ctor_set(x_309, 3, x_247);
-lean_ctor_set_uint8(x_309, sizeof(void*)*4, x_308);
-lean_ctor_set(x_1, 3, x_305);
-lean_ctor_set(x_1, 2, x_304);
-lean_ctor_set(x_1, 1, x_303);
-lean_ctor_set(x_1, 0, x_302);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_308);
-x_310 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_310, 0, x_309);
-lean_ctor_set(x_310, 1, x_300);
-lean_ctor_set(x_310, 2, x_301);
-lean_ctor_set(x_310, 3, x_1);
-lean_ctor_set_uint8(x_310, sizeof(void*)*4, x_275);
-return x_310;
-}
-}
-else
-{
-lean_object* x_311; lean_object* x_312; lean_object* x_313; lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; uint8_t x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; 
-x_311 = lean_ctor_get(x_1, 1);
-x_312 = lean_ctor_get(x_1, 2);
-lean_inc(x_312);
+lean_object* x_308; lean_object* x_309; lean_object* x_310; lean_object* x_311; uint8_t x_312; lean_object* x_313; uint8_t x_314; lean_object* x_315; 
+x_308 = lean_ctor_get(x_249, 0);
+x_309 = lean_ctor_get(x_249, 1);
+x_310 = lean_ctor_get(x_249, 2);
+x_311 = lean_ctor_get(x_249, 3);
 lean_inc(x_311);
-lean_dec(x_1);
-x_313 = lean_ctor_get(x_4, 1);
-lean_inc(x_313);
-x_314 = lean_ctor_get(x_4, 2);
-lean_inc(x_314);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_315 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_315 = lean_box(0);
+lean_inc(x_310);
+lean_inc(x_309);
+lean_inc(x_308);
+lean_dec(x_249);
+x_312 = 1;
+x_313 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_313, 0, x_1);
+lean_ctor_set(x_313, 1, x_2);
+lean_ctor_set(x_313, 2, x_3);
+lean_ctor_set(x_313, 3, x_308);
+lean_ctor_set_uint8(x_313, sizeof(void*)*4, x_312);
+lean_ctor_set(x_4, 0, x_311);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_312);
+x_314 = 0;
+x_315 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_315, 0, x_313);
+lean_ctor_set(x_315, 1, x_309);
+lean_ctor_set(x_315, 2, x_310);
+lean_ctor_set(x_315, 3, x_4);
+lean_ctor_set_uint8(x_315, sizeof(void*)*4, x_314);
+return x_315;
 }
-x_316 = lean_ctor_get(x_248, 0);
-lean_inc(x_316);
-x_317 = lean_ctor_get(x_248, 1);
+}
+else
+{
+lean_object* x_316; lean_object* x_317; lean_object* x_318; lean_object* x_319; lean_object* x_320; lean_object* x_321; lean_object* x_322; uint8_t x_323; lean_object* x_324; lean_object* x_325; uint8_t x_326; lean_object* x_327; 
+x_316 = lean_ctor_get(x_4, 1);
+x_317 = lean_ctor_get(x_4, 2);
 lean_inc(x_317);
-x_318 = lean_ctor_get(x_248, 2);
-lean_inc(x_318);
-x_319 = lean_ctor_get(x_248, 3);
-lean_inc(x_319);
-if (lean_is_exclusive(x_248)) {
- lean_ctor_release(x_248, 0);
- lean_ctor_release(x_248, 1);
- lean_ctor_release(x_248, 2);
- lean_ctor_release(x_248, 3);
- x_320 = x_248;
-} else {
- lean_dec_ref(x_248);
- x_320 = lean_box(0);
-}
-if (lean_is_scalar(x_320)) {
- x_321 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_321 = x_320;
-}
-lean_ctor_set(x_321, 0, x_247);
-lean_ctor_set(x_321, 1, x_311);
-lean_ctor_set(x_321, 2, x_312);
-lean_ctor_set(x_321, 3, x_247);
-lean_ctor_set_uint8(x_321, sizeof(void*)*4, x_275);
-x_322 = 1;
-if (lean_is_scalar(x_315)) {
- x_323 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_323 = x_315;
-}
-lean_ctor_set(x_323, 0, x_321);
-lean_ctor_set(x_323, 1, x_2);
-lean_ctor_set(x_323, 2, x_3);
-lean_ctor_set(x_323, 3, x_247);
-lean_ctor_set_uint8(x_323, sizeof(void*)*4, x_322);
-x_324 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_324, 0, x_316);
-lean_ctor_set(x_324, 1, x_317);
-lean_ctor_set(x_324, 2, x_318);
-lean_ctor_set(x_324, 3, x_319);
-lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_322);
-x_325 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_325, 0, x_323);
-lean_ctor_set(x_325, 1, x_313);
-lean_ctor_set(x_325, 2, x_314);
-lean_ctor_set(x_325, 3, x_324);
-lean_ctor_set_uint8(x_325, sizeof(void*)*4, x_275);
-return x_325;
-}
-}
-else
-{
-uint8_t x_326; 
-x_326 = !lean_is_exclusive(x_248);
-if (x_326 == 0)
-{
-lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; uint8_t x_331; 
-x_327 = lean_ctor_get(x_248, 3);
-lean_dec(x_327);
-x_328 = lean_ctor_get(x_248, 2);
-lean_dec(x_328);
-x_329 = lean_ctor_get(x_248, 1);
-lean_dec(x_329);
-x_330 = lean_ctor_get(x_248, 0);
-lean_dec(x_330);
-x_331 = !lean_is_exclusive(x_1);
-if (x_331 == 0)
-{
-lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; 
-x_332 = lean_ctor_get(x_1, 1);
-x_333 = lean_ctor_get(x_1, 2);
-x_334 = lean_ctor_get(x_1, 3);
-lean_dec(x_334);
-x_335 = lean_ctor_get(x_1, 0);
-lean_dec(x_335);
-lean_ctor_set(x_248, 3, x_247);
-lean_ctor_set(x_248, 2, x_333);
-lean_ctor_set(x_248, 1, x_332);
-lean_ctor_set(x_248, 0, x_247);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_248);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_275);
-return x_1;
-}
-else
-{
-lean_object* x_336; lean_object* x_337; lean_object* x_338; 
-x_336 = lean_ctor_get(x_1, 1);
-x_337 = lean_ctor_get(x_1, 2);
-lean_inc(x_337);
-lean_inc(x_336);
-lean_dec(x_1);
-lean_ctor_set(x_248, 3, x_247);
-lean_ctor_set(x_248, 2, x_337);
-lean_ctor_set(x_248, 1, x_336);
-lean_ctor_set(x_248, 0, x_247);
-lean_ctor_set_uint8(x_248, sizeof(void*)*4, x_246);
-x_338 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_338, 0, x_248);
-lean_ctor_set(x_338, 1, x_2);
-lean_ctor_set(x_338, 2, x_3);
-lean_ctor_set(x_338, 3, x_4);
-lean_ctor_set_uint8(x_338, sizeof(void*)*4, x_275);
-return x_338;
-}
-}
-else
-{
-lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; 
-lean_dec(x_248);
-x_339 = lean_ctor_get(x_1, 1);
-lean_inc(x_339);
-x_340 = lean_ctor_get(x_1, 2);
-lean_inc(x_340);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_341 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_341 = lean_box(0);
-}
-x_342 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_342, 0, x_247);
-lean_ctor_set(x_342, 1, x_339);
-lean_ctor_set(x_342, 2, x_340);
-lean_ctor_set(x_342, 3, x_247);
-lean_ctor_set_uint8(x_342, sizeof(void*)*4, x_246);
-if (lean_is_scalar(x_341)) {
- x_343 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_343 = x_341;
-}
-lean_ctor_set(x_343, 0, x_342);
-lean_ctor_set(x_343, 1, x_2);
-lean_ctor_set(x_343, 2, x_3);
-lean_ctor_set(x_343, 3, x_4);
-lean_ctor_set_uint8(x_343, sizeof(void*)*4, x_275);
-return x_343;
-}
-}
-}
-}
-else
-{
-uint8_t x_344; 
-x_344 = lean_ctor_get_uint8(x_247, sizeof(void*)*4);
-if (x_344 == 0)
-{
-lean_object* x_345; 
-x_345 = lean_ctor_get(x_4, 3);
-lean_inc(x_345);
-if (lean_obj_tag(x_345) == 0)
-{
-uint8_t x_346; 
-x_346 = !lean_is_exclusive(x_1);
-if (x_346 == 0)
-{
-lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; uint8_t x_351; 
-x_347 = lean_ctor_get(x_1, 1);
-x_348 = lean_ctor_get(x_1, 2);
-x_349 = lean_ctor_get(x_1, 3);
-lean_dec(x_349);
-x_350 = lean_ctor_get(x_1, 0);
-lean_dec(x_350);
-x_351 = !lean_is_exclusive(x_4);
-if (x_351 == 0)
-{
-lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; uint8_t x_356; 
-x_352 = lean_ctor_get(x_4, 1);
-x_353 = lean_ctor_get(x_4, 2);
-x_354 = lean_ctor_get(x_4, 3);
-lean_dec(x_354);
-x_355 = lean_ctor_get(x_4, 0);
-lean_dec(x_355);
-x_356 = !lean_is_exclusive(x_247);
-if (x_356 == 0)
-{
-lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; uint8_t x_361; lean_object* x_362; 
-x_357 = lean_ctor_get(x_247, 0);
-x_358 = lean_ctor_get(x_247, 1);
-x_359 = lean_ctor_get(x_247, 2);
-x_360 = lean_ctor_get(x_247, 3);
-lean_ctor_set(x_247, 3, x_345);
-lean_ctor_set(x_247, 2, x_348);
-lean_ctor_set(x_247, 1, x_347);
-lean_ctor_set(x_247, 0, x_345);
-x_361 = 1;
-lean_ctor_set(x_4, 3, x_357);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_361);
-lean_ctor_set(x_1, 3, x_345);
-lean_ctor_set(x_1, 2, x_353);
-lean_ctor_set(x_1, 1, x_352);
-lean_ctor_set(x_1, 0, x_360);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_361);
-x_362 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_362, 0, x_4);
-lean_ctor_set(x_362, 1, x_358);
-lean_ctor_set(x_362, 2, x_359);
-lean_ctor_set(x_362, 3, x_1);
-lean_ctor_set_uint8(x_362, sizeof(void*)*4, x_344);
-return x_362;
-}
-else
-{
-lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; uint8_t x_368; lean_object* x_369; 
-x_363 = lean_ctor_get(x_247, 0);
-x_364 = lean_ctor_get(x_247, 1);
-x_365 = lean_ctor_get(x_247, 2);
-x_366 = lean_ctor_get(x_247, 3);
-lean_inc(x_366);
-lean_inc(x_365);
-lean_inc(x_364);
-lean_inc(x_363);
-lean_dec(x_247);
-x_367 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_367, 0, x_345);
-lean_ctor_set(x_367, 1, x_347);
-lean_ctor_set(x_367, 2, x_348);
-lean_ctor_set(x_367, 3, x_345);
-lean_ctor_set_uint8(x_367, sizeof(void*)*4, x_344);
-x_368 = 1;
-lean_ctor_set(x_4, 3, x_363);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_367);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_368);
-lean_ctor_set(x_1, 3, x_345);
-lean_ctor_set(x_1, 2, x_353);
-lean_ctor_set(x_1, 1, x_352);
-lean_ctor_set(x_1, 0, x_366);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_368);
-x_369 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_369, 0, x_4);
-lean_ctor_set(x_369, 1, x_364);
-lean_ctor_set(x_369, 2, x_365);
-lean_ctor_set(x_369, 3, x_1);
-lean_ctor_set_uint8(x_369, sizeof(void*)*4, x_344);
-return x_369;
-}
-}
-else
-{
-lean_object* x_370; lean_object* x_371; lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; uint8_t x_378; lean_object* x_379; lean_object* x_380; 
-x_370 = lean_ctor_get(x_4, 1);
-x_371 = lean_ctor_get(x_4, 2);
-lean_inc(x_371);
-lean_inc(x_370);
+lean_inc(x_316);
 lean_dec(x_4);
-x_372 = lean_ctor_get(x_247, 0);
-lean_inc(x_372);
-x_373 = lean_ctor_get(x_247, 1);
-lean_inc(x_373);
-x_374 = lean_ctor_get(x_247, 2);
+x_318 = lean_ctor_get(x_249, 0);
+lean_inc(x_318);
+x_319 = lean_ctor_get(x_249, 1);
+lean_inc(x_319);
+x_320 = lean_ctor_get(x_249, 2);
+lean_inc(x_320);
+x_321 = lean_ctor_get(x_249, 3);
+lean_inc(x_321);
+if (lean_is_exclusive(x_249)) {
+ lean_ctor_release(x_249, 0);
+ lean_ctor_release(x_249, 1);
+ lean_ctor_release(x_249, 2);
+ lean_ctor_release(x_249, 3);
+ x_322 = x_249;
+} else {
+ lean_dec_ref(x_249);
+ x_322 = lean_box(0);
+}
+x_323 = 1;
+if (lean_is_scalar(x_322)) {
+ x_324 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_324 = x_322;
+}
+lean_ctor_set(x_324, 0, x_1);
+lean_ctor_set(x_324, 1, x_2);
+lean_ctor_set(x_324, 2, x_3);
+lean_ctor_set(x_324, 3, x_318);
+lean_ctor_set_uint8(x_324, sizeof(void*)*4, x_323);
+x_325 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_325, 0, x_321);
+lean_ctor_set(x_325, 1, x_316);
+lean_ctor_set(x_325, 2, x_317);
+lean_ctor_set(x_325, 3, x_296);
+lean_ctor_set_uint8(x_325, sizeof(void*)*4, x_323);
+x_326 = 0;
+x_327 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_327, 0, x_324);
+lean_ctor_set(x_327, 1, x_319);
+lean_ctor_set(x_327, 2, x_320);
+lean_ctor_set(x_327, 3, x_325);
+lean_ctor_set_uint8(x_327, sizeof(void*)*4, x_326);
+return x_327;
+}
+}
+else
+{
+uint8_t x_328; 
+x_328 = lean_ctor_get_uint8(x_296, sizeof(void*)*4);
+if (x_328 == 0)
+{
+uint8_t x_329; 
+x_329 = !lean_is_exclusive(x_4);
+if (x_329 == 0)
+{
+lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; uint8_t x_334; 
+x_330 = lean_ctor_get(x_4, 1);
+x_331 = lean_ctor_get(x_4, 2);
+x_332 = lean_ctor_get(x_4, 3);
+lean_dec(x_332);
+x_333 = lean_ctor_get(x_4, 0);
+lean_dec(x_333);
+x_334 = !lean_is_exclusive(x_249);
+if (x_334 == 0)
+{
+uint8_t x_335; 
+x_335 = !lean_is_exclusive(x_296);
+if (x_335 == 0)
+{
+lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; uint8_t x_344; uint8_t x_345; lean_object* x_346; 
+x_336 = lean_ctor_get(x_249, 0);
+x_337 = lean_ctor_get(x_249, 1);
+x_338 = lean_ctor_get(x_249, 2);
+x_339 = lean_ctor_get(x_249, 3);
+x_340 = lean_ctor_get(x_296, 0);
+x_341 = lean_ctor_get(x_296, 1);
+x_342 = lean_ctor_get(x_296, 2);
+x_343 = lean_ctor_get(x_296, 3);
+lean_ctor_set(x_296, 3, x_339);
+lean_ctor_set(x_296, 2, x_338);
+lean_ctor_set(x_296, 1, x_337);
+lean_ctor_set(x_296, 0, x_336);
+x_344 = 1;
+lean_ctor_set(x_249, 3, x_296);
+lean_ctor_set(x_249, 2, x_3);
+lean_ctor_set(x_249, 1, x_2);
+lean_ctor_set(x_249, 0, x_1);
+lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_344);
+lean_ctor_set(x_4, 3, x_343);
+lean_ctor_set(x_4, 2, x_342);
+lean_ctor_set(x_4, 1, x_341);
+lean_ctor_set(x_4, 0, x_340);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_344);
+x_345 = 0;
+x_346 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_346, 0, x_249);
+lean_ctor_set(x_346, 1, x_330);
+lean_ctor_set(x_346, 2, x_331);
+lean_ctor_set(x_346, 3, x_4);
+lean_ctor_set_uint8(x_346, sizeof(void*)*4, x_345);
+return x_346;
+}
+else
+{
+lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; uint8_t x_356; uint8_t x_357; lean_object* x_358; 
+x_347 = lean_ctor_get(x_249, 0);
+x_348 = lean_ctor_get(x_249, 1);
+x_349 = lean_ctor_get(x_249, 2);
+x_350 = lean_ctor_get(x_249, 3);
+x_351 = lean_ctor_get(x_296, 0);
+x_352 = lean_ctor_get(x_296, 1);
+x_353 = lean_ctor_get(x_296, 2);
+x_354 = lean_ctor_get(x_296, 3);
+lean_inc(x_354);
+lean_inc(x_353);
+lean_inc(x_352);
+lean_inc(x_351);
+lean_dec(x_296);
+x_355 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_355, 0, x_347);
+lean_ctor_set(x_355, 1, x_348);
+lean_ctor_set(x_355, 2, x_349);
+lean_ctor_set(x_355, 3, x_350);
+lean_ctor_set_uint8(x_355, sizeof(void*)*4, x_328);
+x_356 = 1;
+lean_ctor_set(x_249, 3, x_355);
+lean_ctor_set(x_249, 2, x_3);
+lean_ctor_set(x_249, 1, x_2);
+lean_ctor_set(x_249, 0, x_1);
+lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_356);
+lean_ctor_set(x_4, 3, x_354);
+lean_ctor_set(x_4, 2, x_353);
+lean_ctor_set(x_4, 1, x_352);
+lean_ctor_set(x_4, 0, x_351);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_356);
+x_357 = 0;
+x_358 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_358, 0, x_249);
+lean_ctor_set(x_358, 1, x_330);
+lean_ctor_set(x_358, 2, x_331);
+lean_ctor_set(x_358, 3, x_4);
+lean_ctor_set_uint8(x_358, sizeof(void*)*4, x_357);
+return x_358;
+}
+}
+else
+{
+lean_object* x_359; lean_object* x_360; lean_object* x_361; lean_object* x_362; lean_object* x_363; lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; uint8_t x_369; lean_object* x_370; uint8_t x_371; lean_object* x_372; 
+x_359 = lean_ctor_get(x_249, 0);
+x_360 = lean_ctor_get(x_249, 1);
+x_361 = lean_ctor_get(x_249, 2);
+x_362 = lean_ctor_get(x_249, 3);
+lean_inc(x_362);
+lean_inc(x_361);
+lean_inc(x_360);
+lean_inc(x_359);
+lean_dec(x_249);
+x_363 = lean_ctor_get(x_296, 0);
+lean_inc(x_363);
+x_364 = lean_ctor_get(x_296, 1);
+lean_inc(x_364);
+x_365 = lean_ctor_get(x_296, 2);
+lean_inc(x_365);
+x_366 = lean_ctor_get(x_296, 3);
+lean_inc(x_366);
+if (lean_is_exclusive(x_296)) {
+ lean_ctor_release(x_296, 0);
+ lean_ctor_release(x_296, 1);
+ lean_ctor_release(x_296, 2);
+ lean_ctor_release(x_296, 3);
+ x_367 = x_296;
+} else {
+ lean_dec_ref(x_296);
+ x_367 = lean_box(0);
+}
+if (lean_is_scalar(x_367)) {
+ x_368 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_368 = x_367;
+}
+lean_ctor_set(x_368, 0, x_359);
+lean_ctor_set(x_368, 1, x_360);
+lean_ctor_set(x_368, 2, x_361);
+lean_ctor_set(x_368, 3, x_362);
+lean_ctor_set_uint8(x_368, sizeof(void*)*4, x_328);
+x_369 = 1;
+x_370 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_370, 0, x_1);
+lean_ctor_set(x_370, 1, x_2);
+lean_ctor_set(x_370, 2, x_3);
+lean_ctor_set(x_370, 3, x_368);
+lean_ctor_set_uint8(x_370, sizeof(void*)*4, x_369);
+lean_ctor_set(x_4, 3, x_366);
+lean_ctor_set(x_4, 2, x_365);
+lean_ctor_set(x_4, 1, x_364);
+lean_ctor_set(x_4, 0, x_363);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_369);
+x_371 = 0;
+x_372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_372, 0, x_370);
+lean_ctor_set(x_372, 1, x_330);
+lean_ctor_set(x_372, 2, x_331);
+lean_ctor_set(x_372, 3, x_4);
+lean_ctor_set_uint8(x_372, sizeof(void*)*4, x_371);
+return x_372;
+}
+}
+else
+{
+lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; uint8_t x_386; lean_object* x_387; lean_object* x_388; uint8_t x_389; lean_object* x_390; 
+x_373 = lean_ctor_get(x_4, 1);
+x_374 = lean_ctor_get(x_4, 2);
 lean_inc(x_374);
-x_375 = lean_ctor_get(x_247, 3);
+lean_inc(x_373);
+lean_dec(x_4);
+x_375 = lean_ctor_get(x_249, 0);
 lean_inc(x_375);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_376 = x_247;
+x_376 = lean_ctor_get(x_249, 1);
+lean_inc(x_376);
+x_377 = lean_ctor_get(x_249, 2);
+lean_inc(x_377);
+x_378 = lean_ctor_get(x_249, 3);
+lean_inc(x_378);
+if (lean_is_exclusive(x_249)) {
+ lean_ctor_release(x_249, 0);
+ lean_ctor_release(x_249, 1);
+ lean_ctor_release(x_249, 2);
+ lean_ctor_release(x_249, 3);
+ x_379 = x_249;
 } else {
- lean_dec_ref(x_247);
- x_376 = lean_box(0);
+ lean_dec_ref(x_249);
+ x_379 = lean_box(0);
 }
-if (lean_is_scalar(x_376)) {
- x_377 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_377 = x_376;
-}
-lean_ctor_set(x_377, 0, x_345);
-lean_ctor_set(x_377, 1, x_347);
-lean_ctor_set(x_377, 2, x_348);
-lean_ctor_set(x_377, 3, x_345);
-lean_ctor_set_uint8(x_377, sizeof(void*)*4, x_344);
-x_378 = 1;
-x_379 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_379, 0, x_377);
-lean_ctor_set(x_379, 1, x_2);
-lean_ctor_set(x_379, 2, x_3);
-lean_ctor_set(x_379, 3, x_372);
-lean_ctor_set_uint8(x_379, sizeof(void*)*4, x_378);
-lean_ctor_set(x_1, 3, x_345);
-lean_ctor_set(x_1, 2, x_371);
-lean_ctor_set(x_1, 1, x_370);
-lean_ctor_set(x_1, 0, x_375);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_378);
-x_380 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_380, 0, x_379);
-lean_ctor_set(x_380, 1, x_373);
-lean_ctor_set(x_380, 2, x_374);
-lean_ctor_set(x_380, 3, x_1);
-lean_ctor_set_uint8(x_380, sizeof(void*)*4, x_344);
-return x_380;
-}
-}
-else
-{
-lean_object* x_381; lean_object* x_382; lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; lean_object* x_389; lean_object* x_390; lean_object* x_391; uint8_t x_392; lean_object* x_393; lean_object* x_394; lean_object* x_395; 
-x_381 = lean_ctor_get(x_1, 1);
-x_382 = lean_ctor_get(x_1, 2);
-lean_inc(x_382);
+x_380 = lean_ctor_get(x_296, 0);
+lean_inc(x_380);
+x_381 = lean_ctor_get(x_296, 1);
 lean_inc(x_381);
-lean_dec(x_1);
-x_383 = lean_ctor_get(x_4, 1);
+x_382 = lean_ctor_get(x_296, 2);
+lean_inc(x_382);
+x_383 = lean_ctor_get(x_296, 3);
 lean_inc(x_383);
-x_384 = lean_ctor_get(x_4, 2);
-lean_inc(x_384);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_385 = x_4;
+if (lean_is_exclusive(x_296)) {
+ lean_ctor_release(x_296, 0);
+ lean_ctor_release(x_296, 1);
+ lean_ctor_release(x_296, 2);
+ lean_ctor_release(x_296, 3);
+ x_384 = x_296;
 } else {
- lean_dec_ref(x_4);
- x_385 = lean_box(0);
+ lean_dec_ref(x_296);
+ x_384 = lean_box(0);
 }
-x_386 = lean_ctor_get(x_247, 0);
-lean_inc(x_386);
-x_387 = lean_ctor_get(x_247, 1);
-lean_inc(x_387);
-x_388 = lean_ctor_get(x_247, 2);
-lean_inc(x_388);
-x_389 = lean_ctor_get(x_247, 3);
-lean_inc(x_389);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_390 = x_247;
+if (lean_is_scalar(x_384)) {
+ x_385 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_247);
- x_390 = lean_box(0);
+ x_385 = x_384;
 }
-if (lean_is_scalar(x_390)) {
- x_391 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_385, 0, x_375);
+lean_ctor_set(x_385, 1, x_376);
+lean_ctor_set(x_385, 2, x_377);
+lean_ctor_set(x_385, 3, x_378);
+lean_ctor_set_uint8(x_385, sizeof(void*)*4, x_328);
+x_386 = 1;
+if (lean_is_scalar(x_379)) {
+ x_387 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_391 = x_390;
+ x_387 = x_379;
 }
-lean_ctor_set(x_391, 0, x_345);
-lean_ctor_set(x_391, 1, x_381);
-lean_ctor_set(x_391, 2, x_382);
-lean_ctor_set(x_391, 3, x_345);
-lean_ctor_set_uint8(x_391, sizeof(void*)*4, x_344);
-x_392 = 1;
-if (lean_is_scalar(x_385)) {
- x_393 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_393 = x_385;
-}
-lean_ctor_set(x_393, 0, x_391);
-lean_ctor_set(x_393, 1, x_2);
-lean_ctor_set(x_393, 2, x_3);
-lean_ctor_set(x_393, 3, x_386);
-lean_ctor_set_uint8(x_393, sizeof(void*)*4, x_392);
-x_394 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_394, 0, x_389);
-lean_ctor_set(x_394, 1, x_383);
-lean_ctor_set(x_394, 2, x_384);
-lean_ctor_set(x_394, 3, x_345);
-lean_ctor_set_uint8(x_394, sizeof(void*)*4, x_392);
-x_395 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_395, 0, x_393);
-lean_ctor_set(x_395, 1, x_387);
-lean_ctor_set(x_395, 2, x_388);
-lean_ctor_set(x_395, 3, x_394);
-lean_ctor_set_uint8(x_395, sizeof(void*)*4, x_344);
-return x_395;
+lean_ctor_set(x_387, 0, x_1);
+lean_ctor_set(x_387, 1, x_2);
+lean_ctor_set(x_387, 2, x_3);
+lean_ctor_set(x_387, 3, x_385);
+lean_ctor_set_uint8(x_387, sizeof(void*)*4, x_386);
+x_388 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_388, 0, x_380);
+lean_ctor_set(x_388, 1, x_381);
+lean_ctor_set(x_388, 2, x_382);
+lean_ctor_set(x_388, 3, x_383);
+lean_ctor_set_uint8(x_388, sizeof(void*)*4, x_386);
+x_389 = 0;
+x_390 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_390, 0, x_387);
+lean_ctor_set(x_390, 1, x_373);
+lean_ctor_set(x_390, 2, x_374);
+lean_ctor_set(x_390, 3, x_388);
+lean_ctor_set_uint8(x_390, sizeof(void*)*4, x_389);
+return x_390;
 }
 }
 else
 {
-uint8_t x_396; 
-x_396 = lean_ctor_get_uint8(x_345, sizeof(void*)*4);
-if (x_396 == 0)
+uint8_t x_391; 
+x_391 = !lean_is_exclusive(x_4);
+if (x_391 == 0)
 {
-uint8_t x_397; 
-x_397 = !lean_is_exclusive(x_1);
-if (x_397 == 0)
+lean_object* x_392; lean_object* x_393; uint8_t x_394; 
+x_392 = lean_ctor_get(x_4, 3);
+lean_dec(x_392);
+x_393 = lean_ctor_get(x_4, 0);
+lean_dec(x_393);
+x_394 = !lean_is_exclusive(x_249);
+if (x_394 == 0)
 {
-lean_object* x_398; lean_object* x_399; lean_object* x_400; lean_object* x_401; uint8_t x_402; 
-x_398 = lean_ctor_get(x_1, 1);
-x_399 = lean_ctor_get(x_1, 2);
-x_400 = lean_ctor_get(x_1, 3);
-lean_dec(x_400);
-x_401 = lean_ctor_get(x_1, 0);
-lean_dec(x_401);
-x_402 = !lean_is_exclusive(x_4);
-if (x_402 == 0)
-{
-lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; uint8_t x_407; 
-x_403 = lean_ctor_get(x_4, 1);
-x_404 = lean_ctor_get(x_4, 2);
-x_405 = lean_ctor_get(x_4, 3);
-lean_dec(x_405);
-x_406 = lean_ctor_get(x_4, 0);
-lean_dec(x_406);
-x_407 = !lean_is_exclusive(x_247);
-if (x_407 == 0)
-{
-uint8_t x_408; 
-x_408 = !lean_is_exclusive(x_345);
-if (x_408 == 0)
-{
-lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; uint8_t x_413; lean_object* x_414; 
-x_409 = lean_ctor_get(x_345, 0);
-x_410 = lean_ctor_get(x_345, 1);
-x_411 = lean_ctor_get(x_345, 2);
-x_412 = lean_ctor_get(x_345, 3);
-lean_ctor_set(x_345, 3, x_235);
-lean_ctor_set(x_345, 2, x_399);
-lean_ctor_set(x_345, 1, x_398);
-lean_ctor_set(x_345, 0, x_235);
-lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_396);
-x_413 = 1;
-lean_ctor_set(x_4, 3, x_247);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_345);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_413);
-lean_ctor_set(x_1, 3, x_412);
-lean_ctor_set(x_1, 2, x_411);
-lean_ctor_set(x_1, 1, x_410);
-lean_ctor_set(x_1, 0, x_409);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_413);
-x_414 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_414, 0, x_4);
-lean_ctor_set(x_414, 1, x_403);
-lean_ctor_set(x_414, 2, x_404);
-lean_ctor_set(x_414, 3, x_1);
-lean_ctor_set_uint8(x_414, sizeof(void*)*4, x_396);
-return x_414;
+lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; uint8_t x_399; uint8_t x_400; lean_object* x_401; 
+x_395 = lean_ctor_get(x_249, 0);
+x_396 = lean_ctor_get(x_249, 1);
+x_397 = lean_ctor_get(x_249, 2);
+x_398 = lean_ctor_get(x_249, 3);
+x_399 = 1;
+lean_ctor_set(x_249, 3, x_395);
+lean_ctor_set(x_249, 2, x_3);
+lean_ctor_set(x_249, 1, x_2);
+lean_ctor_set(x_249, 0, x_1);
+lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_399);
+lean_ctor_set(x_4, 0, x_398);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_399);
+x_400 = 0;
+x_401 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_401, 0, x_249);
+lean_ctor_set(x_401, 1, x_396);
+lean_ctor_set(x_401, 2, x_397);
+lean_ctor_set(x_401, 3, x_4);
+lean_ctor_set_uint8(x_401, sizeof(void*)*4, x_400);
+return x_401;
 }
 else
 {
-lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; uint8_t x_420; lean_object* x_421; 
-x_415 = lean_ctor_get(x_345, 0);
-x_416 = lean_ctor_get(x_345, 1);
-x_417 = lean_ctor_get(x_345, 2);
-x_418 = lean_ctor_get(x_345, 3);
-lean_inc(x_418);
-lean_inc(x_417);
-lean_inc(x_416);
+lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; uint8_t x_406; lean_object* x_407; uint8_t x_408; lean_object* x_409; 
+x_402 = lean_ctor_get(x_249, 0);
+x_403 = lean_ctor_get(x_249, 1);
+x_404 = lean_ctor_get(x_249, 2);
+x_405 = lean_ctor_get(x_249, 3);
+lean_inc(x_405);
+lean_inc(x_404);
+lean_inc(x_403);
+lean_inc(x_402);
+lean_dec(x_249);
+x_406 = 1;
+x_407 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_407, 0, x_1);
+lean_ctor_set(x_407, 1, x_2);
+lean_ctor_set(x_407, 2, x_3);
+lean_ctor_set(x_407, 3, x_402);
+lean_ctor_set_uint8(x_407, sizeof(void*)*4, x_406);
+lean_ctor_set(x_4, 0, x_405);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_406);
+x_408 = 0;
+x_409 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_409, 0, x_407);
+lean_ctor_set(x_409, 1, x_403);
+lean_ctor_set(x_409, 2, x_404);
+lean_ctor_set(x_409, 3, x_4);
+lean_ctor_set_uint8(x_409, sizeof(void*)*4, x_408);
+return x_409;
+}
+}
+else
+{
+lean_object* x_410; lean_object* x_411; lean_object* x_412; lean_object* x_413; lean_object* x_414; lean_object* x_415; lean_object* x_416; uint8_t x_417; lean_object* x_418; lean_object* x_419; uint8_t x_420; lean_object* x_421; 
+x_410 = lean_ctor_get(x_4, 1);
+x_411 = lean_ctor_get(x_4, 2);
+lean_inc(x_411);
+lean_inc(x_410);
+lean_dec(x_4);
+x_412 = lean_ctor_get(x_249, 0);
+lean_inc(x_412);
+x_413 = lean_ctor_get(x_249, 1);
+lean_inc(x_413);
+x_414 = lean_ctor_get(x_249, 2);
+lean_inc(x_414);
+x_415 = lean_ctor_get(x_249, 3);
 lean_inc(x_415);
-lean_dec(x_345);
+if (lean_is_exclusive(x_249)) {
+ lean_ctor_release(x_249, 0);
+ lean_ctor_release(x_249, 1);
+ lean_ctor_release(x_249, 2);
+ lean_ctor_release(x_249, 3);
+ x_416 = x_249;
+} else {
+ lean_dec_ref(x_249);
+ x_416 = lean_box(0);
+}
+x_417 = 1;
+if (lean_is_scalar(x_416)) {
+ x_418 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_418 = x_416;
+}
+lean_ctor_set(x_418, 0, x_1);
+lean_ctor_set(x_418, 1, x_2);
+lean_ctor_set(x_418, 2, x_3);
+lean_ctor_set(x_418, 3, x_412);
+lean_ctor_set_uint8(x_418, sizeof(void*)*4, x_417);
 x_419 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_419, 0, x_235);
-lean_ctor_set(x_419, 1, x_398);
-lean_ctor_set(x_419, 2, x_399);
-lean_ctor_set(x_419, 3, x_235);
-lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_396);
-lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_396);
-x_420 = 1;
-lean_ctor_set(x_4, 3, x_247);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_419);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_420);
-lean_ctor_set(x_1, 3, x_418);
-lean_ctor_set(x_1, 2, x_417);
-lean_ctor_set(x_1, 1, x_416);
-lean_ctor_set(x_1, 0, x_415);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_420);
+lean_ctor_set(x_419, 0, x_415);
+lean_ctor_set(x_419, 1, x_410);
+lean_ctor_set(x_419, 2, x_411);
+lean_ctor_set(x_419, 3, x_296);
+lean_ctor_set_uint8(x_419, sizeof(void*)*4, x_417);
+x_420 = 0;
 x_421 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_421, 0, x_4);
-lean_ctor_set(x_421, 1, x_403);
-lean_ctor_set(x_421, 2, x_404);
-lean_ctor_set(x_421, 3, x_1);
-lean_ctor_set_uint8(x_421, sizeof(void*)*4, x_396);
+lean_ctor_set(x_421, 0, x_418);
+lean_ctor_set(x_421, 1, x_413);
+lean_ctor_set(x_421, 2, x_414);
+lean_ctor_set(x_421, 3, x_419);
+lean_ctor_set_uint8(x_421, sizeof(void*)*4, x_420);
 return x_421;
 }
 }
+}
+}
 else
 {
-lean_object* x_422; lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; uint8_t x_433; lean_object* x_434; 
-x_422 = lean_ctor_get(x_247, 0);
-x_423 = lean_ctor_get(x_247, 1);
-x_424 = lean_ctor_get(x_247, 2);
-x_425 = lean_ctor_get(x_247, 3);
-lean_inc(x_425);
-lean_inc(x_424);
-lean_inc(x_423);
+lean_object* x_422; 
+x_422 = lean_ctor_get(x_4, 3);
 lean_inc(x_422);
-lean_dec(x_247);
-x_426 = lean_ctor_get(x_345, 0);
-lean_inc(x_426);
-x_427 = lean_ctor_get(x_345, 1);
-lean_inc(x_427);
-x_428 = lean_ctor_get(x_345, 2);
-lean_inc(x_428);
-x_429 = lean_ctor_get(x_345, 3);
-lean_inc(x_429);
-if (lean_is_exclusive(x_345)) {
- lean_ctor_release(x_345, 0);
- lean_ctor_release(x_345, 1);
- lean_ctor_release(x_345, 2);
- lean_ctor_release(x_345, 3);
- x_430 = x_345;
-} else {
- lean_dec_ref(x_345);
- x_430 = lean_box(0);
+if (lean_obj_tag(x_422) == 0)
+{
+uint8_t x_423; 
+x_423 = !lean_is_exclusive(x_249);
+if (x_423 == 0)
+{
+lean_object* x_424; lean_object* x_425; lean_object* x_426; lean_object* x_427; uint8_t x_428; 
+x_424 = lean_ctor_get(x_249, 3);
+lean_dec(x_424);
+x_425 = lean_ctor_get(x_249, 2);
+lean_dec(x_425);
+x_426 = lean_ctor_get(x_249, 1);
+lean_dec(x_426);
+x_427 = lean_ctor_get(x_249, 0);
+lean_dec(x_427);
+x_428 = 1;
+lean_ctor_set(x_249, 3, x_4);
+lean_ctor_set(x_249, 2, x_3);
+lean_ctor_set(x_249, 1, x_2);
+lean_ctor_set(x_249, 0, x_1);
+lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_428);
+return x_249;
 }
-if (lean_is_scalar(x_430)) {
- x_431 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_431 = x_430;
-}
-lean_ctor_set(x_431, 0, x_235);
-lean_ctor_set(x_431, 1, x_398);
-lean_ctor_set(x_431, 2, x_399);
-lean_ctor_set(x_431, 3, x_235);
-lean_ctor_set_uint8(x_431, sizeof(void*)*4, x_396);
-x_432 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_432, 0, x_422);
-lean_ctor_set(x_432, 1, x_423);
-lean_ctor_set(x_432, 2, x_424);
-lean_ctor_set(x_432, 3, x_425);
-lean_ctor_set_uint8(x_432, sizeof(void*)*4, x_396);
-x_433 = 1;
-lean_ctor_set(x_4, 3, x_432);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_431);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_433);
-lean_ctor_set(x_1, 3, x_429);
-lean_ctor_set(x_1, 2, x_428);
-lean_ctor_set(x_1, 1, x_427);
-lean_ctor_set(x_1, 0, x_426);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_433);
-x_434 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_434, 0, x_4);
-lean_ctor_set(x_434, 1, x_403);
-lean_ctor_set(x_434, 2, x_404);
-lean_ctor_set(x_434, 3, x_1);
-lean_ctor_set_uint8(x_434, sizeof(void*)*4, x_396);
-return x_434;
+else
+{
+uint8_t x_429; lean_object* x_430; 
+lean_dec(x_249);
+x_429 = 1;
+x_430 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_430, 0, x_1);
+lean_ctor_set(x_430, 1, x_2);
+lean_ctor_set(x_430, 2, x_3);
+lean_ctor_set(x_430, 3, x_4);
+lean_ctor_set_uint8(x_430, sizeof(void*)*4, x_429);
+return x_430;
 }
 }
 else
 {
-lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; lean_object* x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; lean_object* x_446; lean_object* x_447; lean_object* x_448; uint8_t x_449; lean_object* x_450; lean_object* x_451; 
-x_435 = lean_ctor_get(x_4, 1);
-x_436 = lean_ctor_get(x_4, 2);
-lean_inc(x_436);
-lean_inc(x_435);
-lean_dec(x_4);
-x_437 = lean_ctor_get(x_247, 0);
-lean_inc(x_437);
-x_438 = lean_ctor_get(x_247, 1);
-lean_inc(x_438);
-x_439 = lean_ctor_get(x_247, 2);
-lean_inc(x_439);
-x_440 = lean_ctor_get(x_247, 3);
-lean_inc(x_440);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_441 = x_247;
-} else {
- lean_dec_ref(x_247);
- x_441 = lean_box(0);
+uint8_t x_431; 
+x_431 = lean_ctor_get_uint8(x_422, sizeof(void*)*4);
+if (x_431 == 0)
+{
+uint8_t x_432; 
+x_432 = !lean_is_exclusive(x_4);
+if (x_432 == 0)
+{
+lean_object* x_433; lean_object* x_434; uint8_t x_435; 
+x_433 = lean_ctor_get(x_4, 3);
+lean_dec(x_433);
+x_434 = lean_ctor_get(x_4, 0);
+lean_dec(x_434);
+x_435 = !lean_is_exclusive(x_422);
+if (x_435 == 0)
+{
+lean_object* x_436; lean_object* x_437; lean_object* x_438; lean_object* x_439; uint8_t x_440; uint8_t x_441; 
+x_436 = lean_ctor_get(x_422, 0);
+x_437 = lean_ctor_get(x_422, 1);
+x_438 = lean_ctor_get(x_422, 2);
+x_439 = lean_ctor_get(x_422, 3);
+x_440 = 1;
+lean_inc(x_249);
+lean_ctor_set(x_422, 3, x_249);
+lean_ctor_set(x_422, 2, x_3);
+lean_ctor_set(x_422, 1, x_2);
+lean_ctor_set(x_422, 0, x_1);
+x_441 = !lean_is_exclusive(x_249);
+if (x_441 == 0)
+{
+lean_object* x_442; lean_object* x_443; lean_object* x_444; lean_object* x_445; uint8_t x_446; 
+x_442 = lean_ctor_get(x_249, 3);
+lean_dec(x_442);
+x_443 = lean_ctor_get(x_249, 2);
+lean_dec(x_443);
+x_444 = lean_ctor_get(x_249, 1);
+lean_dec(x_444);
+x_445 = lean_ctor_get(x_249, 0);
+lean_dec(x_445);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_440);
+lean_ctor_set(x_249, 3, x_439);
+lean_ctor_set(x_249, 2, x_438);
+lean_ctor_set(x_249, 1, x_437);
+lean_ctor_set(x_249, 0, x_436);
+lean_ctor_set_uint8(x_249, sizeof(void*)*4, x_440);
+x_446 = 0;
+lean_ctor_set(x_4, 3, x_249);
+lean_ctor_set(x_4, 0, x_422);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_446);
+return x_4;
 }
-x_442 = lean_ctor_get(x_345, 0);
-lean_inc(x_442);
-x_443 = lean_ctor_get(x_345, 1);
-lean_inc(x_443);
-x_444 = lean_ctor_get(x_345, 2);
-lean_inc(x_444);
-x_445 = lean_ctor_get(x_345, 3);
-lean_inc(x_445);
-if (lean_is_exclusive(x_345)) {
- lean_ctor_release(x_345, 0);
- lean_ctor_release(x_345, 1);
- lean_ctor_release(x_345, 2);
- lean_ctor_release(x_345, 3);
- x_446 = x_345;
-} else {
- lean_dec_ref(x_345);
- x_446 = lean_box(0);
-}
-if (lean_is_scalar(x_446)) {
- x_447 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_447 = x_446;
-}
-lean_ctor_set(x_447, 0, x_235);
-lean_ctor_set(x_447, 1, x_398);
-lean_ctor_set(x_447, 2, x_399);
-lean_ctor_set(x_447, 3, x_235);
-lean_ctor_set_uint8(x_447, sizeof(void*)*4, x_396);
-if (lean_is_scalar(x_441)) {
- x_448 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_448 = x_441;
-}
-lean_ctor_set(x_448, 0, x_437);
-lean_ctor_set(x_448, 1, x_438);
-lean_ctor_set(x_448, 2, x_439);
-lean_ctor_set(x_448, 3, x_440);
-lean_ctor_set_uint8(x_448, sizeof(void*)*4, x_396);
-x_449 = 1;
-x_450 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_450, 0, x_447);
-lean_ctor_set(x_450, 1, x_2);
-lean_ctor_set(x_450, 2, x_3);
-lean_ctor_set(x_450, 3, x_448);
-lean_ctor_set_uint8(x_450, sizeof(void*)*4, x_449);
-lean_ctor_set(x_1, 3, x_445);
-lean_ctor_set(x_1, 2, x_444);
-lean_ctor_set(x_1, 1, x_443);
-lean_ctor_set(x_1, 0, x_442);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_449);
-x_451 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_451, 0, x_450);
-lean_ctor_set(x_451, 1, x_435);
-lean_ctor_set(x_451, 2, x_436);
-lean_ctor_set(x_451, 3, x_1);
-lean_ctor_set_uint8(x_451, sizeof(void*)*4, x_396);
-return x_451;
+else
+{
+lean_object* x_447; uint8_t x_448; 
+lean_dec(x_249);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_440);
+x_447 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_447, 0, x_436);
+lean_ctor_set(x_447, 1, x_437);
+lean_ctor_set(x_447, 2, x_438);
+lean_ctor_set(x_447, 3, x_439);
+lean_ctor_set_uint8(x_447, sizeof(void*)*4, x_440);
+x_448 = 0;
+lean_ctor_set(x_4, 3, x_447);
+lean_ctor_set(x_4, 0, x_422);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_448);
+return x_4;
 }
 }
 else
 {
-lean_object* x_452; lean_object* x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; 
-x_452 = lean_ctor_get(x_1, 1);
-x_453 = lean_ctor_get(x_1, 2);
-lean_inc(x_453);
+lean_object* x_449; lean_object* x_450; lean_object* x_451; lean_object* x_452; uint8_t x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; uint8_t x_457; 
+x_449 = lean_ctor_get(x_422, 0);
+x_450 = lean_ctor_get(x_422, 1);
+x_451 = lean_ctor_get(x_422, 2);
+x_452 = lean_ctor_get(x_422, 3);
 lean_inc(x_452);
-lean_dec(x_1);
-x_454 = lean_ctor_get(x_4, 1);
-lean_inc(x_454);
-x_455 = lean_ctor_get(x_4, 2);
-lean_inc(x_455);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_456 = x_4;
+lean_inc(x_451);
+lean_inc(x_450);
+lean_inc(x_449);
+lean_dec(x_422);
+x_453 = 1;
+lean_inc(x_249);
+x_454 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_454, 0, x_1);
+lean_ctor_set(x_454, 1, x_2);
+lean_ctor_set(x_454, 2, x_3);
+lean_ctor_set(x_454, 3, x_249);
+if (lean_is_exclusive(x_249)) {
+ lean_ctor_release(x_249, 0);
+ lean_ctor_release(x_249, 1);
+ lean_ctor_release(x_249, 2);
+ lean_ctor_release(x_249, 3);
+ x_455 = x_249;
 } else {
- lean_dec_ref(x_4);
- x_456 = lean_box(0);
+ lean_dec_ref(x_249);
+ x_455 = lean_box(0);
 }
-x_457 = lean_ctor_get(x_247, 0);
-lean_inc(x_457);
-x_458 = lean_ctor_get(x_247, 1);
-lean_inc(x_458);
-x_459 = lean_ctor_get(x_247, 2);
+lean_ctor_set_uint8(x_454, sizeof(void*)*4, x_453);
+if (lean_is_scalar(x_455)) {
+ x_456 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_456 = x_455;
+}
+lean_ctor_set(x_456, 0, x_449);
+lean_ctor_set(x_456, 1, x_450);
+lean_ctor_set(x_456, 2, x_451);
+lean_ctor_set(x_456, 3, x_452);
+lean_ctor_set_uint8(x_456, sizeof(void*)*4, x_453);
+x_457 = 0;
+lean_ctor_set(x_4, 3, x_456);
+lean_ctor_set(x_4, 0, x_454);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_457);
+return x_4;
+}
+}
+else
+{
+lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; uint8_t x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; uint8_t x_469; lean_object* x_470; 
+x_458 = lean_ctor_get(x_4, 1);
+x_459 = lean_ctor_get(x_4, 2);
 lean_inc(x_459);
-x_460 = lean_ctor_get(x_247, 3);
+lean_inc(x_458);
+lean_dec(x_4);
+x_460 = lean_ctor_get(x_422, 0);
 lean_inc(x_460);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_461 = x_247;
-} else {
- lean_dec_ref(x_247);
- x_461 = lean_box(0);
-}
-x_462 = lean_ctor_get(x_345, 0);
+x_461 = lean_ctor_get(x_422, 1);
+lean_inc(x_461);
+x_462 = lean_ctor_get(x_422, 2);
 lean_inc(x_462);
-x_463 = lean_ctor_get(x_345, 1);
+x_463 = lean_ctor_get(x_422, 3);
 lean_inc(x_463);
-x_464 = lean_ctor_get(x_345, 2);
-lean_inc(x_464);
-x_465 = lean_ctor_get(x_345, 3);
-lean_inc(x_465);
-if (lean_is_exclusive(x_345)) {
- lean_ctor_release(x_345, 0);
- lean_ctor_release(x_345, 1);
- lean_ctor_release(x_345, 2);
- lean_ctor_release(x_345, 3);
- x_466 = x_345;
+if (lean_is_exclusive(x_422)) {
+ lean_ctor_release(x_422, 0);
+ lean_ctor_release(x_422, 1);
+ lean_ctor_release(x_422, 2);
+ lean_ctor_release(x_422, 3);
+ x_464 = x_422;
 } else {
- lean_dec_ref(x_345);
- x_466 = lean_box(0);
+ lean_dec_ref(x_422);
+ x_464 = lean_box(0);
 }
-if (lean_is_scalar(x_466)) {
- x_467 = lean_alloc_ctor(1, 4, 1);
+x_465 = 1;
+lean_inc(x_249);
+if (lean_is_scalar(x_464)) {
+ x_466 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_467 = x_466;
+ x_466 = x_464;
 }
-lean_ctor_set(x_467, 0, x_235);
-lean_ctor_set(x_467, 1, x_452);
-lean_ctor_set(x_467, 2, x_453);
-lean_ctor_set(x_467, 3, x_235);
-lean_ctor_set_uint8(x_467, sizeof(void*)*4, x_396);
-if (lean_is_scalar(x_461)) {
+lean_ctor_set(x_466, 0, x_1);
+lean_ctor_set(x_466, 1, x_2);
+lean_ctor_set(x_466, 2, x_3);
+lean_ctor_set(x_466, 3, x_249);
+if (lean_is_exclusive(x_249)) {
+ lean_ctor_release(x_249, 0);
+ lean_ctor_release(x_249, 1);
+ lean_ctor_release(x_249, 2);
+ lean_ctor_release(x_249, 3);
+ x_467 = x_249;
+} else {
+ lean_dec_ref(x_249);
+ x_467 = lean_box(0);
+}
+lean_ctor_set_uint8(x_466, sizeof(void*)*4, x_465);
+if (lean_is_scalar(x_467)) {
  x_468 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_468 = x_461;
+ x_468 = x_467;
 }
-lean_ctor_set(x_468, 0, x_457);
-lean_ctor_set(x_468, 1, x_458);
-lean_ctor_set(x_468, 2, x_459);
-lean_ctor_set(x_468, 3, x_460);
-lean_ctor_set_uint8(x_468, sizeof(void*)*4, x_396);
-x_469 = 1;
-if (lean_is_scalar(x_456)) {
- x_470 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_470 = x_456;
-}
-lean_ctor_set(x_470, 0, x_467);
-lean_ctor_set(x_470, 1, x_2);
-lean_ctor_set(x_470, 2, x_3);
+lean_ctor_set(x_468, 0, x_460);
+lean_ctor_set(x_468, 1, x_461);
+lean_ctor_set(x_468, 2, x_462);
+lean_ctor_set(x_468, 3, x_463);
+lean_ctor_set_uint8(x_468, sizeof(void*)*4, x_465);
+x_469 = 0;
+x_470 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_470, 0, x_466);
+lean_ctor_set(x_470, 1, x_458);
+lean_ctor_set(x_470, 2, x_459);
 lean_ctor_set(x_470, 3, x_468);
 lean_ctor_set_uint8(x_470, sizeof(void*)*4, x_469);
-x_471 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_471, 0, x_462);
-lean_ctor_set(x_471, 1, x_463);
-lean_ctor_set(x_471, 2, x_464);
-lean_ctor_set(x_471, 3, x_465);
-lean_ctor_set_uint8(x_471, sizeof(void*)*4, x_469);
-x_472 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_472, 0, x_470);
-lean_ctor_set(x_472, 1, x_454);
-lean_ctor_set(x_472, 2, x_455);
-lean_ctor_set(x_472, 3, x_471);
-lean_ctor_set_uint8(x_472, sizeof(void*)*4, x_396);
-return x_472;
+return x_470;
 }
 }
 else
 {
-uint8_t x_473; 
-x_473 = !lean_is_exclusive(x_1);
-if (x_473 == 0)
+uint8_t x_471; 
+lean_dec(x_249);
+x_471 = !lean_is_exclusive(x_422);
+if (x_471 == 0)
 {
-lean_object* x_474; lean_object* x_475; lean_object* x_476; lean_object* x_477; uint8_t x_478; 
-x_474 = lean_ctor_get(x_1, 1);
-x_475 = lean_ctor_get(x_1, 2);
-x_476 = lean_ctor_get(x_1, 3);
-lean_dec(x_476);
-x_477 = lean_ctor_get(x_1, 0);
-lean_dec(x_477);
-x_478 = !lean_is_exclusive(x_4);
-if (x_478 == 0)
-{
-lean_object* x_479; lean_object* x_480; lean_object* x_481; lean_object* x_482; uint8_t x_483; 
-x_479 = lean_ctor_get(x_4, 1);
-x_480 = lean_ctor_get(x_4, 2);
-x_481 = lean_ctor_get(x_4, 3);
-lean_dec(x_481);
-x_482 = lean_ctor_get(x_4, 0);
-lean_dec(x_482);
-x_483 = !lean_is_exclusive(x_247);
-if (x_483 == 0)
-{
-lean_object* x_484; lean_object* x_485; lean_object* x_486; lean_object* x_487; lean_object* x_488; 
-x_484 = lean_ctor_get(x_247, 0);
-x_485 = lean_ctor_get(x_247, 1);
-x_486 = lean_ctor_get(x_247, 2);
-x_487 = lean_ctor_get(x_247, 3);
-lean_ctor_set(x_247, 3, x_235);
-lean_ctor_set(x_247, 2, x_475);
-lean_ctor_set(x_247, 1, x_474);
-lean_ctor_set(x_247, 0, x_235);
-lean_ctor_set(x_4, 3, x_484);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_396);
-lean_ctor_set(x_1, 3, x_345);
-lean_ctor_set(x_1, 2, x_480);
-lean_ctor_set(x_1, 1, x_479);
-lean_ctor_set(x_1, 0, x_487);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_396);
-x_488 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_488, 0, x_4);
-lean_ctor_set(x_488, 1, x_485);
-lean_ctor_set(x_488, 2, x_486);
-lean_ctor_set(x_488, 3, x_1);
-lean_ctor_set_uint8(x_488, sizeof(void*)*4, x_344);
-return x_488;
+lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; uint8_t x_476; 
+x_472 = lean_ctor_get(x_422, 3);
+lean_dec(x_472);
+x_473 = lean_ctor_get(x_422, 2);
+lean_dec(x_473);
+x_474 = lean_ctor_get(x_422, 1);
+lean_dec(x_474);
+x_475 = lean_ctor_get(x_422, 0);
+lean_dec(x_475);
+x_476 = 1;
+lean_ctor_set(x_422, 3, x_4);
+lean_ctor_set(x_422, 2, x_3);
+lean_ctor_set(x_422, 1, x_2);
+lean_ctor_set(x_422, 0, x_1);
+lean_ctor_set_uint8(x_422, sizeof(void*)*4, x_476);
+return x_422;
 }
 else
 {
-lean_object* x_489; lean_object* x_490; lean_object* x_491; lean_object* x_492; lean_object* x_493; lean_object* x_494; 
-x_489 = lean_ctor_get(x_247, 0);
-x_490 = lean_ctor_get(x_247, 1);
-x_491 = lean_ctor_get(x_247, 2);
-x_492 = lean_ctor_get(x_247, 3);
-lean_inc(x_492);
-lean_inc(x_491);
-lean_inc(x_490);
-lean_inc(x_489);
-lean_dec(x_247);
-x_493 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_493, 0, x_235);
-lean_ctor_set(x_493, 1, x_474);
-lean_ctor_set(x_493, 2, x_475);
-lean_ctor_set(x_493, 3, x_235);
-lean_ctor_set_uint8(x_493, sizeof(void*)*4, x_344);
-lean_ctor_set(x_4, 3, x_489);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_493);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_396);
-lean_ctor_set(x_1, 3, x_345);
-lean_ctor_set(x_1, 2, x_480);
-lean_ctor_set(x_1, 1, x_479);
-lean_ctor_set(x_1, 0, x_492);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_396);
-x_494 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_494, 0, x_4);
-lean_ctor_set(x_494, 1, x_490);
-lean_ctor_set(x_494, 2, x_491);
-lean_ctor_set(x_494, 3, x_1);
-lean_ctor_set_uint8(x_494, sizeof(void*)*4, x_344);
-return x_494;
+uint8_t x_477; lean_object* x_478; 
+lean_dec(x_422);
+x_477 = 1;
+x_478 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_478, 0, x_1);
+lean_ctor_set(x_478, 1, x_2);
+lean_ctor_set(x_478, 2, x_3);
+lean_ctor_set(x_478, 3, x_4);
+lean_ctor_set_uint8(x_478, sizeof(void*)*4, x_477);
+return x_478;
+}
+}
+}
+}
 }
 }
 else
 {
-lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; lean_object* x_504; 
-x_495 = lean_ctor_get(x_4, 1);
-x_496 = lean_ctor_get(x_4, 2);
-lean_inc(x_496);
-lean_inc(x_495);
-lean_dec(x_4);
-x_497 = lean_ctor_get(x_247, 0);
-lean_inc(x_497);
-x_498 = lean_ctor_get(x_247, 1);
-lean_inc(x_498);
-x_499 = lean_ctor_get(x_247, 2);
-lean_inc(x_499);
-x_500 = lean_ctor_get(x_247, 3);
-lean_inc(x_500);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_501 = x_247;
-} else {
- lean_dec_ref(x_247);
- x_501 = lean_box(0);
+uint8_t x_479; lean_object* x_480; 
+x_479 = 1;
+x_480 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_480, 0, x_1);
+lean_ctor_set(x_480, 1, x_2);
+lean_ctor_set(x_480, 2, x_3);
+lean_ctor_set(x_480, 3, x_4);
+lean_ctor_set_uint8(x_480, sizeof(void*)*4, x_479);
+return x_480;
 }
-if (lean_is_scalar(x_501)) {
- x_502 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_502 = x_501;
-}
-lean_ctor_set(x_502, 0, x_235);
-lean_ctor_set(x_502, 1, x_474);
-lean_ctor_set(x_502, 2, x_475);
-lean_ctor_set(x_502, 3, x_235);
-lean_ctor_set_uint8(x_502, sizeof(void*)*4, x_344);
-x_503 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_503, 0, x_502);
-lean_ctor_set(x_503, 1, x_2);
-lean_ctor_set(x_503, 2, x_3);
-lean_ctor_set(x_503, 3, x_497);
-lean_ctor_set_uint8(x_503, sizeof(void*)*4, x_396);
-lean_ctor_set(x_1, 3, x_345);
-lean_ctor_set(x_1, 2, x_496);
-lean_ctor_set(x_1, 1, x_495);
-lean_ctor_set(x_1, 0, x_500);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_396);
-x_504 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_504, 0, x_503);
-lean_ctor_set(x_504, 1, x_498);
-lean_ctor_set(x_504, 2, x_499);
-lean_ctor_set(x_504, 3, x_1);
-lean_ctor_set_uint8(x_504, sizeof(void*)*4, x_344);
-return x_504;
 }
 }
 else
 {
-lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; lean_object* x_509; lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; lean_object* x_516; lean_object* x_517; lean_object* x_518; 
-x_505 = lean_ctor_get(x_1, 1);
-x_506 = lean_ctor_get(x_1, 2);
-lean_inc(x_506);
-lean_inc(x_505);
+lean_object* x_481; lean_object* x_482; lean_object* x_483; 
+x_481 = lean_ctor_get(x_1, 1);
+x_482 = lean_ctor_get(x_1, 2);
+lean_inc(x_482);
+lean_inc(x_481);
 lean_dec(x_1);
-x_507 = lean_ctor_get(x_4, 1);
-lean_inc(x_507);
-x_508 = lean_ctor_get(x_4, 2);
-lean_inc(x_508);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_509 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_509 = lean_box(0);
-}
-x_510 = lean_ctor_get(x_247, 0);
-lean_inc(x_510);
-x_511 = lean_ctor_get(x_247, 1);
-lean_inc(x_511);
-x_512 = lean_ctor_get(x_247, 2);
-lean_inc(x_512);
-x_513 = lean_ctor_get(x_247, 3);
-lean_inc(x_513);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_514 = x_247;
-} else {
- lean_dec_ref(x_247);
- x_514 = lean_box(0);
-}
-if (lean_is_scalar(x_514)) {
- x_515 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_515 = x_514;
-}
-lean_ctor_set(x_515, 0, x_235);
-lean_ctor_set(x_515, 1, x_505);
-lean_ctor_set(x_515, 2, x_506);
-lean_ctor_set(x_515, 3, x_235);
-lean_ctor_set_uint8(x_515, sizeof(void*)*4, x_344);
-if (lean_is_scalar(x_509)) {
- x_516 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_516 = x_509;
-}
-lean_ctor_set(x_516, 0, x_515);
-lean_ctor_set(x_516, 1, x_2);
-lean_ctor_set(x_516, 2, x_3);
-lean_ctor_set(x_516, 3, x_510);
-lean_ctor_set_uint8(x_516, sizeof(void*)*4, x_396);
-x_517 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_517, 0, x_513);
-lean_ctor_set(x_517, 1, x_507);
-lean_ctor_set(x_517, 2, x_508);
-lean_ctor_set(x_517, 3, x_345);
-lean_ctor_set_uint8(x_517, sizeof(void*)*4, x_396);
-x_518 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_518, 0, x_516);
-lean_ctor_set(x_518, 1, x_511);
-lean_ctor_set(x_518, 2, x_512);
-lean_ctor_set(x_518, 3, x_517);
-lean_ctor_set_uint8(x_518, sizeof(void*)*4, x_344);
-return x_518;
-}
-}
-}
-}
-else
-{
-lean_object* x_519; 
-x_519 = lean_ctor_get(x_4, 3);
-lean_inc(x_519);
-if (lean_obj_tag(x_519) == 0)
-{
-uint8_t x_520; 
-x_520 = !lean_is_exclusive(x_247);
-if (x_520 == 0)
-{
-lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; uint8_t x_525; 
-x_521 = lean_ctor_get(x_247, 3);
-lean_dec(x_521);
-x_522 = lean_ctor_get(x_247, 2);
-lean_dec(x_522);
-x_523 = lean_ctor_get(x_247, 1);
-lean_dec(x_523);
-x_524 = lean_ctor_get(x_247, 0);
-lean_dec(x_524);
-x_525 = !lean_is_exclusive(x_1);
-if (x_525 == 0)
-{
-lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; 
-x_526 = lean_ctor_get(x_1, 1);
-x_527 = lean_ctor_get(x_1, 2);
-x_528 = lean_ctor_get(x_1, 3);
-lean_dec(x_528);
-x_529 = lean_ctor_get(x_1, 0);
-lean_dec(x_529);
-lean_ctor_set(x_247, 3, x_519);
-lean_ctor_set(x_247, 2, x_527);
-lean_ctor_set(x_247, 1, x_526);
-lean_ctor_set(x_247, 0, x_519);
-lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_247);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_344);
-return x_1;
-}
-else
-{
-lean_object* x_530; lean_object* x_531; lean_object* x_532; 
-x_530 = lean_ctor_get(x_1, 1);
-x_531 = lean_ctor_get(x_1, 2);
-lean_inc(x_531);
-lean_inc(x_530);
-lean_dec(x_1);
-lean_ctor_set(x_247, 3, x_519);
-lean_ctor_set(x_247, 2, x_531);
-lean_ctor_set(x_247, 1, x_530);
-lean_ctor_set(x_247, 0, x_519);
-lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
-x_532 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_532, 0, x_247);
-lean_ctor_set(x_532, 1, x_2);
-lean_ctor_set(x_532, 2, x_3);
-lean_ctor_set(x_532, 3, x_4);
-lean_ctor_set_uint8(x_532, sizeof(void*)*4, x_344);
-return x_532;
-}
-}
-else
-{
-lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; 
-lean_dec(x_247);
-x_533 = lean_ctor_get(x_1, 1);
-lean_inc(x_533);
-x_534 = lean_ctor_get(x_1, 2);
-lean_inc(x_534);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_535 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_535 = lean_box(0);
-}
-x_536 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_536, 0, x_519);
-lean_ctor_set(x_536, 1, x_533);
-lean_ctor_set(x_536, 2, x_534);
-lean_ctor_set(x_536, 3, x_519);
-lean_ctor_set_uint8(x_536, sizeof(void*)*4, x_246);
-if (lean_is_scalar(x_535)) {
- x_537 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_537 = x_535;
-}
-lean_ctor_set(x_537, 0, x_536);
-lean_ctor_set(x_537, 1, x_2);
-lean_ctor_set(x_537, 2, x_3);
-lean_ctor_set(x_537, 3, x_4);
-lean_ctor_set_uint8(x_537, sizeof(void*)*4, x_344);
-return x_537;
-}
-}
-else
-{
-uint8_t x_538; 
-x_538 = lean_ctor_get_uint8(x_519, sizeof(void*)*4);
-if (x_538 == 0)
-{
-uint8_t x_539; 
-x_539 = !lean_is_exclusive(x_1);
-if (x_539 == 0)
-{
-lean_object* x_540; lean_object* x_541; lean_object* x_542; lean_object* x_543; uint8_t x_544; 
-x_540 = lean_ctor_get(x_1, 1);
-x_541 = lean_ctor_get(x_1, 2);
-x_542 = lean_ctor_get(x_1, 3);
-lean_dec(x_542);
-x_543 = lean_ctor_get(x_1, 0);
-lean_dec(x_543);
-x_544 = !lean_is_exclusive(x_4);
-if (x_544 == 0)
-{
-lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; uint8_t x_549; 
-x_545 = lean_ctor_get(x_4, 1);
-x_546 = lean_ctor_get(x_4, 2);
-x_547 = lean_ctor_get(x_4, 3);
-lean_dec(x_547);
-x_548 = lean_ctor_get(x_4, 0);
-lean_dec(x_548);
-x_549 = !lean_is_exclusive(x_519);
-if (x_549 == 0)
-{
-lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; lean_object* x_554; 
-x_550 = lean_ctor_get(x_519, 0);
-x_551 = lean_ctor_get(x_519, 1);
-x_552 = lean_ctor_get(x_519, 2);
-x_553 = lean_ctor_get(x_519, 3);
-lean_ctor_set(x_519, 3, x_235);
-lean_ctor_set(x_519, 2, x_541);
-lean_ctor_set(x_519, 1, x_540);
-lean_ctor_set(x_519, 0, x_235);
-lean_ctor_set(x_4, 3, x_247);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_519);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_344);
-lean_ctor_set(x_1, 3, x_553);
-lean_ctor_set(x_1, 2, x_552);
-lean_ctor_set(x_1, 1, x_551);
-lean_ctor_set(x_1, 0, x_550);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_344);
-x_554 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_554, 0, x_4);
-lean_ctor_set(x_554, 1, x_545);
-lean_ctor_set(x_554, 2, x_546);
-lean_ctor_set(x_554, 3, x_1);
-lean_ctor_set_uint8(x_554, sizeof(void*)*4, x_538);
-return x_554;
-}
-else
-{
-lean_object* x_555; lean_object* x_556; lean_object* x_557; lean_object* x_558; lean_object* x_559; lean_object* x_560; 
-x_555 = lean_ctor_get(x_519, 0);
-x_556 = lean_ctor_get(x_519, 1);
-x_557 = lean_ctor_get(x_519, 2);
-x_558 = lean_ctor_get(x_519, 3);
-lean_inc(x_558);
-lean_inc(x_557);
-lean_inc(x_556);
-lean_inc(x_555);
-lean_dec(x_519);
-x_559 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_559, 0, x_235);
-lean_ctor_set(x_559, 1, x_540);
-lean_ctor_set(x_559, 2, x_541);
-lean_ctor_set(x_559, 3, x_235);
-lean_ctor_set_uint8(x_559, sizeof(void*)*4, x_538);
-lean_ctor_set(x_4, 3, x_247);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_559);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_344);
-lean_ctor_set(x_1, 3, x_558);
-lean_ctor_set(x_1, 2, x_557);
-lean_ctor_set(x_1, 1, x_556);
-lean_ctor_set(x_1, 0, x_555);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_344);
-x_560 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_560, 0, x_4);
-lean_ctor_set(x_560, 1, x_545);
-lean_ctor_set(x_560, 2, x_546);
-lean_ctor_set(x_560, 3, x_1);
-lean_ctor_set_uint8(x_560, sizeof(void*)*4, x_538);
-return x_560;
-}
-}
-else
-{
-lean_object* x_561; lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; lean_object* x_568; lean_object* x_569; lean_object* x_570; 
-x_561 = lean_ctor_get(x_4, 1);
-x_562 = lean_ctor_get(x_4, 2);
-lean_inc(x_562);
-lean_inc(x_561);
-lean_dec(x_4);
-x_563 = lean_ctor_get(x_519, 0);
-lean_inc(x_563);
-x_564 = lean_ctor_get(x_519, 1);
-lean_inc(x_564);
-x_565 = lean_ctor_get(x_519, 2);
-lean_inc(x_565);
-x_566 = lean_ctor_get(x_519, 3);
-lean_inc(x_566);
-if (lean_is_exclusive(x_519)) {
- lean_ctor_release(x_519, 0);
- lean_ctor_release(x_519, 1);
- lean_ctor_release(x_519, 2);
- lean_ctor_release(x_519, 3);
- x_567 = x_519;
-} else {
- lean_dec_ref(x_519);
- x_567 = lean_box(0);
-}
-if (lean_is_scalar(x_567)) {
- x_568 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_568 = x_567;
-}
-lean_ctor_set(x_568, 0, x_235);
-lean_ctor_set(x_568, 1, x_540);
-lean_ctor_set(x_568, 2, x_541);
-lean_ctor_set(x_568, 3, x_235);
-lean_ctor_set_uint8(x_568, sizeof(void*)*4, x_538);
-x_569 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_569, 0, x_568);
-lean_ctor_set(x_569, 1, x_2);
-lean_ctor_set(x_569, 2, x_3);
-lean_ctor_set(x_569, 3, x_247);
-lean_ctor_set_uint8(x_569, sizeof(void*)*4, x_344);
-lean_ctor_set(x_1, 3, x_566);
-lean_ctor_set(x_1, 2, x_565);
-lean_ctor_set(x_1, 1, x_564);
-lean_ctor_set(x_1, 0, x_563);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_344);
-x_570 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_570, 0, x_569);
-lean_ctor_set(x_570, 1, x_561);
-lean_ctor_set(x_570, 2, x_562);
-lean_ctor_set(x_570, 3, x_1);
-lean_ctor_set_uint8(x_570, sizeof(void*)*4, x_538);
-return x_570;
-}
-}
-else
-{
-lean_object* x_571; lean_object* x_572; lean_object* x_573; lean_object* x_574; lean_object* x_575; lean_object* x_576; lean_object* x_577; lean_object* x_578; lean_object* x_579; lean_object* x_580; lean_object* x_581; lean_object* x_582; lean_object* x_583; lean_object* x_584; 
-x_571 = lean_ctor_get(x_1, 1);
-x_572 = lean_ctor_get(x_1, 2);
-lean_inc(x_572);
-lean_inc(x_571);
-lean_dec(x_1);
-x_573 = lean_ctor_get(x_4, 1);
-lean_inc(x_573);
-x_574 = lean_ctor_get(x_4, 2);
-lean_inc(x_574);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_575 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_575 = lean_box(0);
-}
-x_576 = lean_ctor_get(x_519, 0);
-lean_inc(x_576);
-x_577 = lean_ctor_get(x_519, 1);
-lean_inc(x_577);
-x_578 = lean_ctor_get(x_519, 2);
-lean_inc(x_578);
-x_579 = lean_ctor_get(x_519, 3);
-lean_inc(x_579);
-if (lean_is_exclusive(x_519)) {
- lean_ctor_release(x_519, 0);
- lean_ctor_release(x_519, 1);
- lean_ctor_release(x_519, 2);
- lean_ctor_release(x_519, 3);
- x_580 = x_519;
-} else {
- lean_dec_ref(x_519);
- x_580 = lean_box(0);
-}
-if (lean_is_scalar(x_580)) {
- x_581 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_581 = x_580;
-}
-lean_ctor_set(x_581, 0, x_235);
-lean_ctor_set(x_581, 1, x_571);
-lean_ctor_set(x_581, 2, x_572);
-lean_ctor_set(x_581, 3, x_235);
-lean_ctor_set_uint8(x_581, sizeof(void*)*4, x_538);
-if (lean_is_scalar(x_575)) {
- x_582 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_582 = x_575;
-}
-lean_ctor_set(x_582, 0, x_581);
-lean_ctor_set(x_582, 1, x_2);
-lean_ctor_set(x_582, 2, x_3);
-lean_ctor_set(x_582, 3, x_247);
-lean_ctor_set_uint8(x_582, sizeof(void*)*4, x_344);
-x_583 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_583, 0, x_576);
-lean_ctor_set(x_583, 1, x_577);
-lean_ctor_set(x_583, 2, x_578);
-lean_ctor_set(x_583, 3, x_579);
-lean_ctor_set_uint8(x_583, sizeof(void*)*4, x_344);
-x_584 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_584, 0, x_582);
-lean_ctor_set(x_584, 1, x_573);
-lean_ctor_set(x_584, 2, x_574);
-lean_ctor_set(x_584, 3, x_583);
-lean_ctor_set_uint8(x_584, sizeof(void*)*4, x_538);
-return x_584;
-}
-}
-else
-{
-uint8_t x_585; 
-x_585 = !lean_is_exclusive(x_1);
-if (x_585 == 0)
-{
-lean_object* x_586; lean_object* x_587; lean_object* x_588; lean_object* x_589; uint8_t x_590; 
-x_586 = lean_ctor_get(x_1, 1);
-x_587 = lean_ctor_get(x_1, 2);
-x_588 = lean_ctor_get(x_1, 3);
-lean_dec(x_588);
-x_589 = lean_ctor_get(x_1, 0);
-lean_dec(x_589);
-x_590 = !lean_is_exclusive(x_4);
-if (x_590 == 0)
-{
-lean_object* x_591; lean_object* x_592; lean_object* x_593; lean_object* x_594; uint8_t x_595; 
-x_591 = lean_ctor_get(x_4, 1);
-x_592 = lean_ctor_get(x_4, 2);
-x_593 = lean_ctor_get(x_4, 3);
-lean_dec(x_593);
-x_594 = lean_ctor_get(x_4, 0);
-lean_dec(x_594);
-x_595 = !lean_is_exclusive(x_247);
-if (x_595 == 0)
-{
-lean_object* x_596; lean_object* x_597; lean_object* x_598; lean_object* x_599; lean_object* x_600; 
-x_596 = lean_ctor_get(x_247, 0);
-x_597 = lean_ctor_get(x_247, 1);
-x_598 = lean_ctor_get(x_247, 2);
-x_599 = lean_ctor_get(x_247, 3);
-lean_ctor_set(x_247, 3, x_235);
-lean_ctor_set(x_247, 2, x_587);
-lean_ctor_set(x_247, 1, x_586);
-lean_ctor_set(x_247, 0, x_235);
-lean_ctor_set_uint8(x_247, sizeof(void*)*4, x_246);
-lean_ctor_set(x_4, 3, x_599);
-lean_ctor_set(x_4, 2, x_598);
-lean_ctor_set(x_4, 1, x_597);
-lean_ctor_set(x_4, 0, x_596);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_538);
-lean_ctor_set(x_1, 3, x_519);
-lean_ctor_set(x_1, 2, x_592);
-lean_ctor_set(x_1, 1, x_591);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_246);
-x_600 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_600, 0, x_247);
-lean_ctor_set(x_600, 1, x_2);
-lean_ctor_set(x_600, 2, x_3);
-lean_ctor_set(x_600, 3, x_1);
-lean_ctor_set_uint8(x_600, sizeof(void*)*4, x_538);
-return x_600;
-}
-else
-{
-lean_object* x_601; lean_object* x_602; lean_object* x_603; lean_object* x_604; lean_object* x_605; lean_object* x_606; 
-x_601 = lean_ctor_get(x_247, 0);
-x_602 = lean_ctor_get(x_247, 1);
-x_603 = lean_ctor_get(x_247, 2);
-x_604 = lean_ctor_get(x_247, 3);
-lean_inc(x_604);
-lean_inc(x_603);
-lean_inc(x_602);
-lean_inc(x_601);
-lean_dec(x_247);
-x_605 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_605, 0, x_235);
-lean_ctor_set(x_605, 1, x_586);
-lean_ctor_set(x_605, 2, x_587);
-lean_ctor_set(x_605, 3, x_235);
-lean_ctor_set_uint8(x_605, sizeof(void*)*4, x_246);
-lean_ctor_set(x_4, 3, x_604);
-lean_ctor_set(x_4, 2, x_603);
-lean_ctor_set(x_4, 1, x_602);
-lean_ctor_set(x_4, 0, x_601);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_538);
-lean_ctor_set(x_1, 3, x_519);
-lean_ctor_set(x_1, 2, x_592);
-lean_ctor_set(x_1, 1, x_591);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_246);
-x_606 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_606, 0, x_605);
-lean_ctor_set(x_606, 1, x_2);
-lean_ctor_set(x_606, 2, x_3);
-lean_ctor_set(x_606, 3, x_1);
-lean_ctor_set_uint8(x_606, sizeof(void*)*4, x_538);
-return x_606;
-}
-}
-else
-{
-lean_object* x_607; lean_object* x_608; lean_object* x_609; lean_object* x_610; lean_object* x_611; lean_object* x_612; lean_object* x_613; lean_object* x_614; lean_object* x_615; lean_object* x_616; 
-x_607 = lean_ctor_get(x_4, 1);
-x_608 = lean_ctor_get(x_4, 2);
-lean_inc(x_608);
-lean_inc(x_607);
-lean_dec(x_4);
-x_609 = lean_ctor_get(x_247, 0);
-lean_inc(x_609);
-x_610 = lean_ctor_get(x_247, 1);
-lean_inc(x_610);
-x_611 = lean_ctor_get(x_247, 2);
-lean_inc(x_611);
-x_612 = lean_ctor_get(x_247, 3);
-lean_inc(x_612);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_613 = x_247;
-} else {
- lean_dec_ref(x_247);
- x_613 = lean_box(0);
-}
-if (lean_is_scalar(x_613)) {
- x_614 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_614 = x_613;
-}
-lean_ctor_set(x_614, 0, x_235);
-lean_ctor_set(x_614, 1, x_586);
-lean_ctor_set(x_614, 2, x_587);
-lean_ctor_set(x_614, 3, x_235);
-lean_ctor_set_uint8(x_614, sizeof(void*)*4, x_246);
-x_615 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_615, 0, x_609);
-lean_ctor_set(x_615, 1, x_610);
-lean_ctor_set(x_615, 2, x_611);
-lean_ctor_set(x_615, 3, x_612);
-lean_ctor_set_uint8(x_615, sizeof(void*)*4, x_538);
-lean_ctor_set(x_1, 3, x_519);
-lean_ctor_set(x_1, 2, x_608);
-lean_ctor_set(x_1, 1, x_607);
-lean_ctor_set(x_1, 0, x_615);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_246);
-x_616 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_616, 0, x_614);
-lean_ctor_set(x_616, 1, x_2);
-lean_ctor_set(x_616, 2, x_3);
-lean_ctor_set(x_616, 3, x_1);
-lean_ctor_set_uint8(x_616, sizeof(void*)*4, x_538);
-return x_616;
-}
-}
-else
-{
-lean_object* x_617; lean_object* x_618; lean_object* x_619; lean_object* x_620; lean_object* x_621; lean_object* x_622; lean_object* x_623; lean_object* x_624; lean_object* x_625; lean_object* x_626; lean_object* x_627; lean_object* x_628; lean_object* x_629; lean_object* x_630; 
-x_617 = lean_ctor_get(x_1, 1);
-x_618 = lean_ctor_get(x_1, 2);
-lean_inc(x_618);
-lean_inc(x_617);
-lean_dec(x_1);
-x_619 = lean_ctor_get(x_4, 1);
-lean_inc(x_619);
-x_620 = lean_ctor_get(x_4, 2);
-lean_inc(x_620);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_621 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_621 = lean_box(0);
-}
-x_622 = lean_ctor_get(x_247, 0);
-lean_inc(x_622);
-x_623 = lean_ctor_get(x_247, 1);
-lean_inc(x_623);
-x_624 = lean_ctor_get(x_247, 2);
-lean_inc(x_624);
-x_625 = lean_ctor_get(x_247, 3);
-lean_inc(x_625);
-if (lean_is_exclusive(x_247)) {
- lean_ctor_release(x_247, 0);
- lean_ctor_release(x_247, 1);
- lean_ctor_release(x_247, 2);
- lean_ctor_release(x_247, 3);
- x_626 = x_247;
-} else {
- lean_dec_ref(x_247);
- x_626 = lean_box(0);
-}
-if (lean_is_scalar(x_626)) {
- x_627 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_627 = x_626;
-}
-lean_ctor_set(x_627, 0, x_235);
-lean_ctor_set(x_627, 1, x_617);
-lean_ctor_set(x_627, 2, x_618);
-lean_ctor_set(x_627, 3, x_235);
-lean_ctor_set_uint8(x_627, sizeof(void*)*4, x_246);
-if (lean_is_scalar(x_621)) {
- x_628 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_628 = x_621;
-}
-lean_ctor_set(x_628, 0, x_622);
-lean_ctor_set(x_628, 1, x_623);
-lean_ctor_set(x_628, 2, x_624);
-lean_ctor_set(x_628, 3, x_625);
-lean_ctor_set_uint8(x_628, sizeof(void*)*4, x_538);
-x_629 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_629, 0, x_628);
-lean_ctor_set(x_629, 1, x_619);
-lean_ctor_set(x_629, 2, x_620);
-lean_ctor_set(x_629, 3, x_519);
-lean_ctor_set_uint8(x_629, sizeof(void*)*4, x_246);
-x_630 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_630, 0, x_627);
-lean_ctor_set(x_630, 1, x_2);
-lean_ctor_set(x_630, 2, x_3);
-lean_ctor_set(x_630, 3, x_629);
-lean_ctor_set_uint8(x_630, sizeof(void*)*4, x_538);
-return x_630;
-}
-}
-}
-}
-}
-}
-else
-{
-uint8_t x_631; 
-x_631 = !lean_is_exclusive(x_1);
-if (x_631 == 0)
-{
-lean_object* x_632; lean_object* x_633; lean_object* x_634; 
-x_632 = lean_ctor_get(x_1, 3);
-lean_dec(x_632);
-x_633 = lean_ctor_get(x_1, 0);
-lean_dec(x_633);
-lean_ctor_set(x_1, 0, x_235);
-x_634 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_634, 0, x_1);
-lean_ctor_set(x_634, 1, x_2);
-lean_ctor_set(x_634, 2, x_3);
-lean_ctor_set(x_634, 3, x_4);
-lean_ctor_set_uint8(x_634, sizeof(void*)*4, x_246);
-return x_634;
-}
-else
-{
-lean_object* x_635; lean_object* x_636; lean_object* x_637; lean_object* x_638; 
-x_635 = lean_ctor_get(x_1, 1);
-x_636 = lean_ctor_get(x_1, 2);
-lean_inc(x_636);
-lean_inc(x_635);
-lean_dec(x_1);
-x_637 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_637, 0, x_235);
-lean_ctor_set(x_637, 1, x_635);
-lean_ctor_set(x_637, 2, x_636);
-lean_ctor_set(x_637, 3, x_235);
-lean_ctor_set_uint8(x_637, sizeof(void*)*4, x_233);
-x_638 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_638, 0, x_637);
-lean_ctor_set(x_638, 1, x_2);
-lean_ctor_set(x_638, 2, x_3);
-lean_ctor_set(x_638, 3, x_4);
-lean_ctor_set_uint8(x_638, sizeof(void*)*4, x_246);
-return x_638;
-}
-}
-}
-}
-else
-{
-uint8_t x_639; 
-x_639 = lean_ctor_get_uint8(x_235, sizeof(void*)*4);
-if (x_639 == 0)
-{
-uint8_t x_640; 
-x_640 = !lean_is_exclusive(x_1);
-if (x_640 == 0)
-{
-lean_object* x_641; lean_object* x_642; lean_object* x_643; lean_object* x_644; uint8_t x_645; 
-x_641 = lean_ctor_get(x_1, 1);
-x_642 = lean_ctor_get(x_1, 2);
-x_643 = lean_ctor_get(x_1, 3);
-lean_dec(x_643);
-x_644 = lean_ctor_get(x_1, 0);
-lean_dec(x_644);
-x_645 = !lean_is_exclusive(x_235);
-if (x_645 == 0)
-{
-lean_object* x_646; lean_object* x_647; lean_object* x_648; lean_object* x_649; uint8_t x_650; lean_object* x_651; 
-x_646 = lean_ctor_get(x_235, 0);
-x_647 = lean_ctor_get(x_235, 1);
-x_648 = lean_ctor_get(x_235, 2);
-x_649 = lean_ctor_get(x_235, 3);
-x_650 = 1;
-lean_ctor_set(x_235, 3, x_646);
-lean_ctor_set(x_235, 2, x_642);
-lean_ctor_set(x_235, 1, x_641);
-lean_ctor_set(x_235, 0, x_234);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_650);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_649);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_650);
-x_651 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_651, 0, x_235);
-lean_ctor_set(x_651, 1, x_647);
-lean_ctor_set(x_651, 2, x_648);
-lean_ctor_set(x_651, 3, x_1);
-lean_ctor_set_uint8(x_651, sizeof(void*)*4, x_639);
-return x_651;
-}
-else
-{
-lean_object* x_652; lean_object* x_653; lean_object* x_654; lean_object* x_655; uint8_t x_656; lean_object* x_657; lean_object* x_658; 
-x_652 = lean_ctor_get(x_235, 0);
-x_653 = lean_ctor_get(x_235, 1);
-x_654 = lean_ctor_get(x_235, 2);
-x_655 = lean_ctor_get(x_235, 3);
-lean_inc(x_655);
-lean_inc(x_654);
-lean_inc(x_653);
-lean_inc(x_652);
-lean_dec(x_235);
-x_656 = 1;
-x_657 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_657, 0, x_234);
-lean_ctor_set(x_657, 1, x_641);
-lean_ctor_set(x_657, 2, x_642);
-lean_ctor_set(x_657, 3, x_652);
-lean_ctor_set_uint8(x_657, sizeof(void*)*4, x_656);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_655);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_656);
-x_658 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_658, 0, x_657);
-lean_ctor_set(x_658, 1, x_653);
-lean_ctor_set(x_658, 2, x_654);
-lean_ctor_set(x_658, 3, x_1);
-lean_ctor_set_uint8(x_658, sizeof(void*)*4, x_639);
-return x_658;
-}
-}
-else
-{
-lean_object* x_659; lean_object* x_660; lean_object* x_661; lean_object* x_662; lean_object* x_663; lean_object* x_664; lean_object* x_665; uint8_t x_666; lean_object* x_667; lean_object* x_668; lean_object* x_669; 
-x_659 = lean_ctor_get(x_1, 1);
-x_660 = lean_ctor_get(x_1, 2);
-lean_inc(x_660);
-lean_inc(x_659);
-lean_dec(x_1);
-x_661 = lean_ctor_get(x_235, 0);
-lean_inc(x_661);
-x_662 = lean_ctor_get(x_235, 1);
-lean_inc(x_662);
-x_663 = lean_ctor_get(x_235, 2);
-lean_inc(x_663);
-x_664 = lean_ctor_get(x_235, 3);
-lean_inc(x_664);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_665 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_665 = lean_box(0);
-}
-x_666 = 1;
-if (lean_is_scalar(x_665)) {
- x_667 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_667 = x_665;
-}
-lean_ctor_set(x_667, 0, x_234);
-lean_ctor_set(x_667, 1, x_659);
-lean_ctor_set(x_667, 2, x_660);
-lean_ctor_set(x_667, 3, x_661);
-lean_ctor_set_uint8(x_667, sizeof(void*)*4, x_666);
-x_668 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_668, 0, x_664);
-lean_ctor_set(x_668, 1, x_2);
-lean_ctor_set(x_668, 2, x_3);
-lean_ctor_set(x_668, 3, x_4);
-lean_ctor_set_uint8(x_668, sizeof(void*)*4, x_666);
-x_669 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_669, 0, x_667);
-lean_ctor_set(x_669, 1, x_662);
-lean_ctor_set(x_669, 2, x_663);
-lean_ctor_set(x_669, 3, x_668);
-lean_ctor_set_uint8(x_669, sizeof(void*)*4, x_639);
-return x_669;
-}
-}
-else
-{
+x_483 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_483, 0, x_242);
+lean_ctor_set(x_483, 1, x_481);
+lean_ctor_set(x_483, 2, x_482);
+lean_ctor_set(x_483, 3, x_242);
+lean_ctor_set_uint8(x_483, sizeof(void*)*4, x_240);
 if (lean_obj_tag(x_4) == 0)
 {
-uint8_t x_670; 
-x_670 = !lean_is_exclusive(x_1);
-if (x_670 == 0)
-{
-lean_object* x_671; lean_object* x_672; lean_object* x_673; 
-x_671 = lean_ctor_get(x_1, 3);
-lean_dec(x_671);
-x_672 = lean_ctor_get(x_1, 0);
-lean_dec(x_672);
-lean_ctor_set(x_1, 0, x_4);
-x_673 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_673, 0, x_1);
-lean_ctor_set(x_673, 1, x_2);
-lean_ctor_set(x_673, 2, x_3);
-lean_ctor_set(x_673, 3, x_4);
-lean_ctor_set_uint8(x_673, sizeof(void*)*4, x_639);
-return x_673;
+uint8_t x_484; lean_object* x_485; 
+x_484 = 1;
+x_485 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_485, 0, x_483);
+lean_ctor_set(x_485, 1, x_2);
+lean_ctor_set(x_485, 2, x_3);
+lean_ctor_set(x_485, 3, x_4);
+lean_ctor_set_uint8(x_485, sizeof(void*)*4, x_484);
+return x_485;
 }
 else
 {
-lean_object* x_674; lean_object* x_675; lean_object* x_676; lean_object* x_677; 
-x_674 = lean_ctor_get(x_1, 1);
-x_675 = lean_ctor_get(x_1, 2);
-lean_inc(x_675);
-lean_inc(x_674);
-lean_dec(x_1);
-x_676 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_676, 0, x_4);
-lean_ctor_set(x_676, 1, x_674);
-lean_ctor_set(x_676, 2, x_675);
-lean_ctor_set(x_676, 3, x_235);
-lean_ctor_set_uint8(x_676, sizeof(void*)*4, x_233);
-x_677 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_677, 0, x_676);
-lean_ctor_set(x_677, 1, x_2);
-lean_ctor_set(x_677, 2, x_3);
-lean_ctor_set(x_677, 3, x_4);
-lean_ctor_set_uint8(x_677, sizeof(void*)*4, x_639);
-return x_677;
-}
+uint8_t x_486; 
+x_486 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_486 == 0)
+{
+lean_object* x_487; 
+x_487 = lean_ctor_get(x_4, 0);
+lean_inc(x_487);
+if (lean_obj_tag(x_487) == 0)
+{
+lean_object* x_488; 
+x_488 = lean_ctor_get(x_4, 3);
+lean_inc(x_488);
+if (lean_obj_tag(x_488) == 0)
+{
+uint8_t x_489; lean_object* x_490; 
+x_489 = 1;
+x_490 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_490, 0, x_483);
+lean_ctor_set(x_490, 1, x_2);
+lean_ctor_set(x_490, 2, x_3);
+lean_ctor_set(x_490, 3, x_4);
+lean_ctor_set_uint8(x_490, sizeof(void*)*4, x_489);
+return x_490;
 }
 else
 {
-uint8_t x_678; 
-x_678 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
-if (x_678 == 0)
+uint8_t x_491; 
+x_491 = lean_ctor_get_uint8(x_488, sizeof(void*)*4);
+if (x_491 == 0)
 {
-lean_object* x_679; 
-x_679 = lean_ctor_get(x_4, 0);
-lean_inc(x_679);
-if (lean_obj_tag(x_679) == 0)
-{
-lean_object* x_680; 
-x_680 = lean_ctor_get(x_4, 3);
-lean_inc(x_680);
-if (lean_obj_tag(x_680) == 0)
-{
-uint8_t x_681; 
-x_681 = !lean_is_exclusive(x_1);
-if (x_681 == 0)
-{
-lean_object* x_682; lean_object* x_683; lean_object* x_684; lean_object* x_685; uint8_t x_686; 
-x_682 = lean_ctor_get(x_1, 1);
-x_683 = lean_ctor_get(x_1, 2);
-x_684 = lean_ctor_get(x_1, 3);
-lean_dec(x_684);
-x_685 = lean_ctor_get(x_1, 0);
-lean_dec(x_685);
-x_686 = !lean_is_exclusive(x_4);
-if (x_686 == 0)
-{
-lean_object* x_687; lean_object* x_688; lean_object* x_689; lean_object* x_690; uint8_t x_691; 
-x_687 = lean_ctor_get(x_4, 1);
-x_688 = lean_ctor_get(x_4, 2);
-x_689 = lean_ctor_get(x_4, 3);
-lean_dec(x_689);
-x_690 = lean_ctor_get(x_4, 0);
-lean_dec(x_690);
-lean_inc(x_235);
-lean_ctor_set(x_4, 3, x_235);
-lean_ctor_set(x_4, 2, x_683);
-lean_ctor_set(x_4, 1, x_682);
-lean_ctor_set(x_4, 0, x_680);
-x_691 = !lean_is_exclusive(x_235);
-if (x_691 == 0)
-{
-lean_object* x_692; lean_object* x_693; lean_object* x_694; lean_object* x_695; 
-x_692 = lean_ctor_get(x_235, 3);
-lean_dec(x_692);
-x_693 = lean_ctor_get(x_235, 2);
-lean_dec(x_693);
-x_694 = lean_ctor_get(x_235, 1);
-lean_dec(x_694);
-x_695 = lean_ctor_get(x_235, 0);
-lean_dec(x_695);
-lean_ctor_set(x_235, 3, x_680);
-lean_ctor_set(x_235, 2, x_688);
-lean_ctor_set(x_235, 1, x_687);
-lean_ctor_set(x_235, 0, x_680);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_639);
-return x_1;
-}
-else
-{
-lean_object* x_696; 
-lean_dec(x_235);
-x_696 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_696, 0, x_680);
-lean_ctor_set(x_696, 1, x_687);
-lean_ctor_set(x_696, 2, x_688);
-lean_ctor_set(x_696, 3, x_680);
-lean_ctor_set_uint8(x_696, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 3, x_696);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_639);
-return x_1;
-}
-}
-else
-{
-lean_object* x_697; lean_object* x_698; lean_object* x_699; lean_object* x_700; lean_object* x_701; 
-x_697 = lean_ctor_get(x_4, 1);
-x_698 = lean_ctor_get(x_4, 2);
-lean_inc(x_698);
-lean_inc(x_697);
-lean_dec(x_4);
-lean_inc(x_235);
-x_699 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_699, 0, x_680);
-lean_ctor_set(x_699, 1, x_682);
-lean_ctor_set(x_699, 2, x_683);
-lean_ctor_set(x_699, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_700 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_700 = lean_box(0);
-}
-lean_ctor_set_uint8(x_699, sizeof(void*)*4, x_678);
-if (lean_is_scalar(x_700)) {
- x_701 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_701 = x_700;
-}
-lean_ctor_set(x_701, 0, x_680);
-lean_ctor_set(x_701, 1, x_697);
-lean_ctor_set(x_701, 2, x_698);
-lean_ctor_set(x_701, 3, x_680);
-lean_ctor_set_uint8(x_701, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 3, x_701);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_699);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_639);
-return x_1;
-}
-}
-else
-{
-lean_object* x_702; lean_object* x_703; lean_object* x_704; lean_object* x_705; lean_object* x_706; lean_object* x_707; lean_object* x_708; lean_object* x_709; lean_object* x_710; 
-x_702 = lean_ctor_get(x_1, 1);
-x_703 = lean_ctor_get(x_1, 2);
-lean_inc(x_703);
-lean_inc(x_702);
-lean_dec(x_1);
-x_704 = lean_ctor_get(x_4, 1);
-lean_inc(x_704);
-x_705 = lean_ctor_get(x_4, 2);
-lean_inc(x_705);
+lean_object* x_492; lean_object* x_493; lean_object* x_494; lean_object* x_495; lean_object* x_496; lean_object* x_497; lean_object* x_498; lean_object* x_499; uint8_t x_500; lean_object* x_501; lean_object* x_502; uint8_t x_503; lean_object* x_504; 
+x_492 = lean_ctor_get(x_4, 1);
+lean_inc(x_492);
+x_493 = lean_ctor_get(x_4, 2);
+lean_inc(x_493);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
- x_706 = x_4;
+ x_494 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_706 = lean_box(0);
+ x_494 = lean_box(0);
 }
-lean_inc(x_235);
-if (lean_is_scalar(x_706)) {
- x_707 = lean_alloc_ctor(1, 4, 1);
+x_495 = lean_ctor_get(x_488, 0);
+lean_inc(x_495);
+x_496 = lean_ctor_get(x_488, 1);
+lean_inc(x_496);
+x_497 = lean_ctor_get(x_488, 2);
+lean_inc(x_497);
+x_498 = lean_ctor_get(x_488, 3);
+lean_inc(x_498);
+if (lean_is_exclusive(x_488)) {
+ lean_ctor_release(x_488, 0);
+ lean_ctor_release(x_488, 1);
+ lean_ctor_release(x_488, 2);
+ lean_ctor_release(x_488, 3);
+ x_499 = x_488;
 } else {
- x_707 = x_706;
+ lean_dec_ref(x_488);
+ x_499 = lean_box(0);
 }
-lean_ctor_set(x_707, 0, x_680);
-lean_ctor_set(x_707, 1, x_702);
-lean_ctor_set(x_707, 2, x_703);
-lean_ctor_set(x_707, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_708 = x_235;
+x_500 = 1;
+if (lean_is_scalar(x_499)) {
+ x_501 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_235);
- x_708 = lean_box(0);
+ x_501 = x_499;
 }
-lean_ctor_set_uint8(x_707, sizeof(void*)*4, x_678);
-if (lean_is_scalar(x_708)) {
- x_709 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_501, 0, x_483);
+lean_ctor_set(x_501, 1, x_2);
+lean_ctor_set(x_501, 2, x_3);
+lean_ctor_set(x_501, 3, x_487);
+lean_ctor_set_uint8(x_501, sizeof(void*)*4, x_500);
+if (lean_is_scalar(x_494)) {
+ x_502 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_709 = x_708;
+ x_502 = x_494;
+}
+lean_ctor_set(x_502, 0, x_495);
+lean_ctor_set(x_502, 1, x_496);
+lean_ctor_set(x_502, 2, x_497);
+lean_ctor_set(x_502, 3, x_498);
+lean_ctor_set_uint8(x_502, sizeof(void*)*4, x_500);
+x_503 = 0;
+x_504 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_504, 0, x_501);
+lean_ctor_set(x_504, 1, x_492);
+lean_ctor_set(x_504, 2, x_493);
+lean_ctor_set(x_504, 3, x_502);
+lean_ctor_set_uint8(x_504, sizeof(void*)*4, x_503);
+return x_504;
+}
+else
+{
+lean_object* x_505; uint8_t x_506; lean_object* x_507; 
+if (lean_is_exclusive(x_488)) {
+ lean_ctor_release(x_488, 0);
+ lean_ctor_release(x_488, 1);
+ lean_ctor_release(x_488, 2);
+ lean_ctor_release(x_488, 3);
+ x_505 = x_488;
+} else {
+ lean_dec_ref(x_488);
+ x_505 = lean_box(0);
+}
+x_506 = 1;
+if (lean_is_scalar(x_505)) {
+ x_507 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_507 = x_505;
+}
+lean_ctor_set(x_507, 0, x_483);
+lean_ctor_set(x_507, 1, x_2);
+lean_ctor_set(x_507, 2, x_3);
+lean_ctor_set(x_507, 3, x_4);
+lean_ctor_set_uint8(x_507, sizeof(void*)*4, x_506);
+return x_507;
 }
-lean_ctor_set(x_709, 0, x_680);
-lean_ctor_set(x_709, 1, x_704);
-lean_ctor_set(x_709, 2, x_705);
-lean_ctor_set(x_709, 3, x_680);
-lean_ctor_set_uint8(x_709, sizeof(void*)*4, x_678);
-x_710 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_710, 0, x_707);
-lean_ctor_set(x_710, 1, x_2);
-lean_ctor_set(x_710, 2, x_3);
-lean_ctor_set(x_710, 3, x_709);
-lean_ctor_set_uint8(x_710, sizeof(void*)*4, x_639);
-return x_710;
 }
 }
 else
 {
-uint8_t x_711; 
-x_711 = lean_ctor_get_uint8(x_680, sizeof(void*)*4);
-if (x_711 == 0)
+uint8_t x_508; 
+x_508 = lean_ctor_get_uint8(x_487, sizeof(void*)*4);
+if (x_508 == 0)
 {
-uint8_t x_712; 
-x_712 = !lean_is_exclusive(x_1);
-if (x_712 == 0)
+lean_object* x_509; 
+x_509 = lean_ctor_get(x_4, 3);
+lean_inc(x_509);
+if (lean_obj_tag(x_509) == 0)
 {
-lean_object* x_713; lean_object* x_714; lean_object* x_715; lean_object* x_716; uint8_t x_717; 
-x_713 = lean_ctor_get(x_1, 1);
-x_714 = lean_ctor_get(x_1, 2);
-x_715 = lean_ctor_get(x_1, 3);
-lean_dec(x_715);
-x_716 = lean_ctor_get(x_1, 0);
-lean_dec(x_716);
-x_717 = !lean_is_exclusive(x_4);
-if (x_717 == 0)
-{
-lean_object* x_718; lean_object* x_719; lean_object* x_720; lean_object* x_721; uint8_t x_722; 
-x_718 = lean_ctor_get(x_4, 1);
-x_719 = lean_ctor_get(x_4, 2);
-x_720 = lean_ctor_get(x_4, 3);
-lean_dec(x_720);
-x_721 = lean_ctor_get(x_4, 0);
-lean_dec(x_721);
-x_722 = !lean_is_exclusive(x_680);
-if (x_722 == 0)
-{
-lean_object* x_723; lean_object* x_724; lean_object* x_725; lean_object* x_726; uint8_t x_727; 
-x_723 = lean_ctor_get(x_680, 0);
-x_724 = lean_ctor_get(x_680, 1);
-x_725 = lean_ctor_get(x_680, 2);
-x_726 = lean_ctor_get(x_680, 3);
-lean_inc(x_235);
-lean_ctor_set(x_680, 3, x_235);
-lean_ctor_set(x_680, 2, x_714);
-lean_ctor_set(x_680, 1, x_713);
-lean_ctor_set(x_680, 0, x_679);
-x_727 = !lean_is_exclusive(x_235);
-if (x_727 == 0)
-{
-lean_object* x_728; lean_object* x_729; lean_object* x_730; lean_object* x_731; 
-x_728 = lean_ctor_get(x_235, 3);
-lean_dec(x_728);
-x_729 = lean_ctor_get(x_235, 2);
-lean_dec(x_729);
-x_730 = lean_ctor_get(x_235, 1);
-lean_dec(x_730);
-x_731 = lean_ctor_get(x_235, 0);
-lean_dec(x_731);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_680);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-lean_ctor_set(x_235, 3, x_726);
-lean_ctor_set(x_235, 2, x_725);
-lean_ctor_set(x_235, 1, x_724);
-lean_ctor_set(x_235, 0, x_723);
-lean_ctor_set(x_1, 2, x_719);
-lean_ctor_set(x_1, 1, x_718);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_711);
-return x_1;
+lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; lean_object* x_516; lean_object* x_517; uint8_t x_518; lean_object* x_519; lean_object* x_520; uint8_t x_521; lean_object* x_522; 
+x_510 = lean_ctor_get(x_4, 1);
+lean_inc(x_510);
+x_511 = lean_ctor_get(x_4, 2);
+lean_inc(x_511);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_512 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_512 = lean_box(0);
+}
+x_513 = lean_ctor_get(x_487, 0);
+lean_inc(x_513);
+x_514 = lean_ctor_get(x_487, 1);
+lean_inc(x_514);
+x_515 = lean_ctor_get(x_487, 2);
+lean_inc(x_515);
+x_516 = lean_ctor_get(x_487, 3);
+lean_inc(x_516);
+if (lean_is_exclusive(x_487)) {
+ lean_ctor_release(x_487, 0);
+ lean_ctor_release(x_487, 1);
+ lean_ctor_release(x_487, 2);
+ lean_ctor_release(x_487, 3);
+ x_517 = x_487;
+} else {
+ lean_dec_ref(x_487);
+ x_517 = lean_box(0);
+}
+x_518 = 1;
+if (lean_is_scalar(x_517)) {
+ x_519 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_519 = x_517;
+}
+lean_ctor_set(x_519, 0, x_483);
+lean_ctor_set(x_519, 1, x_2);
+lean_ctor_set(x_519, 2, x_3);
+lean_ctor_set(x_519, 3, x_513);
+lean_ctor_set_uint8(x_519, sizeof(void*)*4, x_518);
+if (lean_is_scalar(x_512)) {
+ x_520 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_520 = x_512;
+}
+lean_ctor_set(x_520, 0, x_516);
+lean_ctor_set(x_520, 1, x_510);
+lean_ctor_set(x_520, 2, x_511);
+lean_ctor_set(x_520, 3, x_509);
+lean_ctor_set_uint8(x_520, sizeof(void*)*4, x_518);
+x_521 = 0;
+x_522 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_522, 0, x_519);
+lean_ctor_set(x_522, 1, x_514);
+lean_ctor_set(x_522, 2, x_515);
+lean_ctor_set(x_522, 3, x_520);
+lean_ctor_set_uint8(x_522, sizeof(void*)*4, x_521);
+return x_522;
 }
 else
 {
-lean_object* x_732; 
-lean_dec(x_235);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_680);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-x_732 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_732, 0, x_723);
-lean_ctor_set(x_732, 1, x_724);
-lean_ctor_set(x_732, 2, x_725);
-lean_ctor_set(x_732, 3, x_726);
-lean_ctor_set_uint8(x_732, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_732);
-lean_ctor_set(x_1, 2, x_719);
-lean_ctor_set(x_1, 1, x_718);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_711);
-return x_1;
+uint8_t x_523; 
+x_523 = lean_ctor_get_uint8(x_509, sizeof(void*)*4);
+if (x_523 == 0)
+{
+lean_object* x_524; lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; uint8_t x_538; lean_object* x_539; lean_object* x_540; uint8_t x_541; lean_object* x_542; 
+x_524 = lean_ctor_get(x_4, 1);
+lean_inc(x_524);
+x_525 = lean_ctor_get(x_4, 2);
+lean_inc(x_525);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_526 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_526 = lean_box(0);
+}
+x_527 = lean_ctor_get(x_487, 0);
+lean_inc(x_527);
+x_528 = lean_ctor_get(x_487, 1);
+lean_inc(x_528);
+x_529 = lean_ctor_get(x_487, 2);
+lean_inc(x_529);
+x_530 = lean_ctor_get(x_487, 3);
+lean_inc(x_530);
+if (lean_is_exclusive(x_487)) {
+ lean_ctor_release(x_487, 0);
+ lean_ctor_release(x_487, 1);
+ lean_ctor_release(x_487, 2);
+ lean_ctor_release(x_487, 3);
+ x_531 = x_487;
+} else {
+ lean_dec_ref(x_487);
+ x_531 = lean_box(0);
+}
+x_532 = lean_ctor_get(x_509, 0);
+lean_inc(x_532);
+x_533 = lean_ctor_get(x_509, 1);
+lean_inc(x_533);
+x_534 = lean_ctor_get(x_509, 2);
+lean_inc(x_534);
+x_535 = lean_ctor_get(x_509, 3);
+lean_inc(x_535);
+if (lean_is_exclusive(x_509)) {
+ lean_ctor_release(x_509, 0);
+ lean_ctor_release(x_509, 1);
+ lean_ctor_release(x_509, 2);
+ lean_ctor_release(x_509, 3);
+ x_536 = x_509;
+} else {
+ lean_dec_ref(x_509);
+ x_536 = lean_box(0);
+}
+if (lean_is_scalar(x_536)) {
+ x_537 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_537 = x_536;
+}
+lean_ctor_set(x_537, 0, x_527);
+lean_ctor_set(x_537, 1, x_528);
+lean_ctor_set(x_537, 2, x_529);
+lean_ctor_set(x_537, 3, x_530);
+lean_ctor_set_uint8(x_537, sizeof(void*)*4, x_523);
+x_538 = 1;
+if (lean_is_scalar(x_531)) {
+ x_539 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_539 = x_531;
+}
+lean_ctor_set(x_539, 0, x_483);
+lean_ctor_set(x_539, 1, x_2);
+lean_ctor_set(x_539, 2, x_3);
+lean_ctor_set(x_539, 3, x_537);
+lean_ctor_set_uint8(x_539, sizeof(void*)*4, x_538);
+if (lean_is_scalar(x_526)) {
+ x_540 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_540 = x_526;
+}
+lean_ctor_set(x_540, 0, x_532);
+lean_ctor_set(x_540, 1, x_533);
+lean_ctor_set(x_540, 2, x_534);
+lean_ctor_set(x_540, 3, x_535);
+lean_ctor_set_uint8(x_540, sizeof(void*)*4, x_538);
+x_541 = 0;
+x_542 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_542, 0, x_539);
+lean_ctor_set(x_542, 1, x_524);
+lean_ctor_set(x_542, 2, x_525);
+lean_ctor_set(x_542, 3, x_540);
+lean_ctor_set_uint8(x_542, sizeof(void*)*4, x_541);
+return x_542;
+}
+else
+{
+lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; uint8_t x_551; lean_object* x_552; lean_object* x_553; uint8_t x_554; lean_object* x_555; 
+x_543 = lean_ctor_get(x_4, 1);
+lean_inc(x_543);
+x_544 = lean_ctor_get(x_4, 2);
+lean_inc(x_544);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_545 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_545 = lean_box(0);
+}
+x_546 = lean_ctor_get(x_487, 0);
+lean_inc(x_546);
+x_547 = lean_ctor_get(x_487, 1);
+lean_inc(x_547);
+x_548 = lean_ctor_get(x_487, 2);
+lean_inc(x_548);
+x_549 = lean_ctor_get(x_487, 3);
+lean_inc(x_549);
+if (lean_is_exclusive(x_487)) {
+ lean_ctor_release(x_487, 0);
+ lean_ctor_release(x_487, 1);
+ lean_ctor_release(x_487, 2);
+ lean_ctor_release(x_487, 3);
+ x_550 = x_487;
+} else {
+ lean_dec_ref(x_487);
+ x_550 = lean_box(0);
+}
+x_551 = 1;
+if (lean_is_scalar(x_550)) {
+ x_552 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_552 = x_550;
+}
+lean_ctor_set(x_552, 0, x_483);
+lean_ctor_set(x_552, 1, x_2);
+lean_ctor_set(x_552, 2, x_3);
+lean_ctor_set(x_552, 3, x_546);
+lean_ctor_set_uint8(x_552, sizeof(void*)*4, x_551);
+if (lean_is_scalar(x_545)) {
+ x_553 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_553 = x_545;
+}
+lean_ctor_set(x_553, 0, x_549);
+lean_ctor_set(x_553, 1, x_543);
+lean_ctor_set(x_553, 2, x_544);
+lean_ctor_set(x_553, 3, x_509);
+lean_ctor_set_uint8(x_553, sizeof(void*)*4, x_551);
+x_554 = 0;
+x_555 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_555, 0, x_552);
+lean_ctor_set(x_555, 1, x_547);
+lean_ctor_set(x_555, 2, x_548);
+lean_ctor_set(x_555, 3, x_553);
+lean_ctor_set_uint8(x_555, sizeof(void*)*4, x_554);
+return x_555;
+}
 }
 }
 else
 {
-lean_object* x_733; lean_object* x_734; lean_object* x_735; lean_object* x_736; lean_object* x_737; lean_object* x_738; lean_object* x_739; 
-x_733 = lean_ctor_get(x_680, 0);
-x_734 = lean_ctor_get(x_680, 1);
-x_735 = lean_ctor_get(x_680, 2);
-x_736 = lean_ctor_get(x_680, 3);
+lean_object* x_556; 
+x_556 = lean_ctor_get(x_4, 3);
+lean_inc(x_556);
+if (lean_obj_tag(x_556) == 0)
+{
+lean_object* x_557; uint8_t x_558; lean_object* x_559; 
+if (lean_is_exclusive(x_487)) {
+ lean_ctor_release(x_487, 0);
+ lean_ctor_release(x_487, 1);
+ lean_ctor_release(x_487, 2);
+ lean_ctor_release(x_487, 3);
+ x_557 = x_487;
+} else {
+ lean_dec_ref(x_487);
+ x_557 = lean_box(0);
+}
+x_558 = 1;
+if (lean_is_scalar(x_557)) {
+ x_559 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_559 = x_557;
+}
+lean_ctor_set(x_559, 0, x_483);
+lean_ctor_set(x_559, 1, x_2);
+lean_ctor_set(x_559, 2, x_3);
+lean_ctor_set(x_559, 3, x_4);
+lean_ctor_set_uint8(x_559, sizeof(void*)*4, x_558);
+return x_559;
+}
+else
+{
+uint8_t x_560; 
+x_560 = lean_ctor_get_uint8(x_556, sizeof(void*)*4);
+if (x_560 == 0)
+{
+lean_object* x_561; lean_object* x_562; lean_object* x_563; lean_object* x_564; lean_object* x_565; lean_object* x_566; lean_object* x_567; lean_object* x_568; uint8_t x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; uint8_t x_573; lean_object* x_574; 
+x_561 = lean_ctor_get(x_4, 1);
+lean_inc(x_561);
+x_562 = lean_ctor_get(x_4, 2);
+lean_inc(x_562);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_563 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_563 = lean_box(0);
+}
+x_564 = lean_ctor_get(x_556, 0);
+lean_inc(x_564);
+x_565 = lean_ctor_get(x_556, 1);
+lean_inc(x_565);
+x_566 = lean_ctor_get(x_556, 2);
+lean_inc(x_566);
+x_567 = lean_ctor_get(x_556, 3);
+lean_inc(x_567);
+if (lean_is_exclusive(x_556)) {
+ lean_ctor_release(x_556, 0);
+ lean_ctor_release(x_556, 1);
+ lean_ctor_release(x_556, 2);
+ lean_ctor_release(x_556, 3);
+ x_568 = x_556;
+} else {
+ lean_dec_ref(x_556);
+ x_568 = lean_box(0);
+}
+x_569 = 1;
+lean_inc(x_487);
+if (lean_is_scalar(x_568)) {
+ x_570 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_570 = x_568;
+}
+lean_ctor_set(x_570, 0, x_483);
+lean_ctor_set(x_570, 1, x_2);
+lean_ctor_set(x_570, 2, x_3);
+lean_ctor_set(x_570, 3, x_487);
+if (lean_is_exclusive(x_487)) {
+ lean_ctor_release(x_487, 0);
+ lean_ctor_release(x_487, 1);
+ lean_ctor_release(x_487, 2);
+ lean_ctor_release(x_487, 3);
+ x_571 = x_487;
+} else {
+ lean_dec_ref(x_487);
+ x_571 = lean_box(0);
+}
+lean_ctor_set_uint8(x_570, sizeof(void*)*4, x_569);
+if (lean_is_scalar(x_571)) {
+ x_572 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_572 = x_571;
+}
+lean_ctor_set(x_572, 0, x_564);
+lean_ctor_set(x_572, 1, x_565);
+lean_ctor_set(x_572, 2, x_566);
+lean_ctor_set(x_572, 3, x_567);
+lean_ctor_set_uint8(x_572, sizeof(void*)*4, x_569);
+x_573 = 0;
+if (lean_is_scalar(x_563)) {
+ x_574 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_574 = x_563;
+}
+lean_ctor_set(x_574, 0, x_570);
+lean_ctor_set(x_574, 1, x_561);
+lean_ctor_set(x_574, 2, x_562);
+lean_ctor_set(x_574, 3, x_572);
+lean_ctor_set_uint8(x_574, sizeof(void*)*4, x_573);
+return x_574;
+}
+else
+{
+lean_object* x_575; uint8_t x_576; lean_object* x_577; 
+lean_dec(x_487);
+if (lean_is_exclusive(x_556)) {
+ lean_ctor_release(x_556, 0);
+ lean_ctor_release(x_556, 1);
+ lean_ctor_release(x_556, 2);
+ lean_ctor_release(x_556, 3);
+ x_575 = x_556;
+} else {
+ lean_dec_ref(x_556);
+ x_575 = lean_box(0);
+}
+x_576 = 1;
+if (lean_is_scalar(x_575)) {
+ x_577 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_577 = x_575;
+}
+lean_ctor_set(x_577, 0, x_483);
+lean_ctor_set(x_577, 1, x_2);
+lean_ctor_set(x_577, 2, x_3);
+lean_ctor_set(x_577, 3, x_4);
+lean_ctor_set_uint8(x_577, sizeof(void*)*4, x_576);
+return x_577;
+}
+}
+}
+}
+}
+else
+{
+uint8_t x_578; lean_object* x_579; 
+x_578 = 1;
+x_579 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_579, 0, x_483);
+lean_ctor_set(x_579, 1, x_2);
+lean_ctor_set(x_579, 2, x_3);
+lean_ctor_set(x_579, 3, x_4);
+lean_ctor_set_uint8(x_579, sizeof(void*)*4, x_578);
+return x_579;
+}
+}
+}
+}
+else
+{
+uint8_t x_580; 
+x_580 = lean_ctor_get_uint8(x_242, sizeof(void*)*4);
+if (x_580 == 0)
+{
+uint8_t x_581; 
+x_581 = !lean_is_exclusive(x_1);
+if (x_581 == 0)
+{
+lean_object* x_582; lean_object* x_583; lean_object* x_584; lean_object* x_585; uint8_t x_586; 
+x_582 = lean_ctor_get(x_1, 1);
+x_583 = lean_ctor_get(x_1, 2);
+x_584 = lean_ctor_get(x_1, 3);
+lean_dec(x_584);
+x_585 = lean_ctor_get(x_1, 0);
+lean_dec(x_585);
+x_586 = !lean_is_exclusive(x_242);
+if (x_586 == 0)
+{
+lean_object* x_587; lean_object* x_588; lean_object* x_589; lean_object* x_590; uint8_t x_591; uint8_t x_592; lean_object* x_593; 
+x_587 = lean_ctor_get(x_242, 0);
+x_588 = lean_ctor_get(x_242, 1);
+x_589 = lean_ctor_get(x_242, 2);
+x_590 = lean_ctor_get(x_242, 3);
+x_591 = 1;
+lean_ctor_set(x_242, 3, x_587);
+lean_ctor_set(x_242, 2, x_583);
+lean_ctor_set(x_242, 1, x_582);
+lean_ctor_set(x_242, 0, x_241);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_591);
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set(x_1, 0, x_590);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_591);
+x_592 = 0;
+x_593 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_593, 0, x_242);
+lean_ctor_set(x_593, 1, x_588);
+lean_ctor_set(x_593, 2, x_589);
+lean_ctor_set(x_593, 3, x_1);
+lean_ctor_set_uint8(x_593, sizeof(void*)*4, x_592);
+return x_593;
+}
+else
+{
+lean_object* x_594; lean_object* x_595; lean_object* x_596; lean_object* x_597; uint8_t x_598; lean_object* x_599; uint8_t x_600; lean_object* x_601; 
+x_594 = lean_ctor_get(x_242, 0);
+x_595 = lean_ctor_get(x_242, 1);
+x_596 = lean_ctor_get(x_242, 2);
+x_597 = lean_ctor_get(x_242, 3);
+lean_inc(x_597);
+lean_inc(x_596);
+lean_inc(x_595);
+lean_inc(x_594);
+lean_dec(x_242);
+x_598 = 1;
+x_599 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_599, 0, x_241);
+lean_ctor_set(x_599, 1, x_582);
+lean_ctor_set(x_599, 2, x_583);
+lean_ctor_set(x_599, 3, x_594);
+lean_ctor_set_uint8(x_599, sizeof(void*)*4, x_598);
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set(x_1, 0, x_597);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_598);
+x_600 = 0;
+x_601 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_601, 0, x_599);
+lean_ctor_set(x_601, 1, x_595);
+lean_ctor_set(x_601, 2, x_596);
+lean_ctor_set(x_601, 3, x_1);
+lean_ctor_set_uint8(x_601, sizeof(void*)*4, x_600);
+return x_601;
+}
+}
+else
+{
+lean_object* x_602; lean_object* x_603; lean_object* x_604; lean_object* x_605; lean_object* x_606; lean_object* x_607; lean_object* x_608; uint8_t x_609; lean_object* x_610; lean_object* x_611; uint8_t x_612; lean_object* x_613; 
+x_602 = lean_ctor_get(x_1, 1);
+x_603 = lean_ctor_get(x_1, 2);
+lean_inc(x_603);
+lean_inc(x_602);
+lean_dec(x_1);
+x_604 = lean_ctor_get(x_242, 0);
+lean_inc(x_604);
+x_605 = lean_ctor_get(x_242, 1);
+lean_inc(x_605);
+x_606 = lean_ctor_get(x_242, 2);
+lean_inc(x_606);
+x_607 = lean_ctor_get(x_242, 3);
+lean_inc(x_607);
+if (lean_is_exclusive(x_242)) {
+ lean_ctor_release(x_242, 0);
+ lean_ctor_release(x_242, 1);
+ lean_ctor_release(x_242, 2);
+ lean_ctor_release(x_242, 3);
+ x_608 = x_242;
+} else {
+ lean_dec_ref(x_242);
+ x_608 = lean_box(0);
+}
+x_609 = 1;
+if (lean_is_scalar(x_608)) {
+ x_610 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_610 = x_608;
+}
+lean_ctor_set(x_610, 0, x_241);
+lean_ctor_set(x_610, 1, x_602);
+lean_ctor_set(x_610, 2, x_603);
+lean_ctor_set(x_610, 3, x_604);
+lean_ctor_set_uint8(x_610, sizeof(void*)*4, x_609);
+x_611 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_611, 0, x_607);
+lean_ctor_set(x_611, 1, x_2);
+lean_ctor_set(x_611, 2, x_3);
+lean_ctor_set(x_611, 3, x_4);
+lean_ctor_set_uint8(x_611, sizeof(void*)*4, x_609);
+x_612 = 0;
+x_613 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_613, 0, x_610);
+lean_ctor_set(x_613, 1, x_605);
+lean_ctor_set(x_613, 2, x_606);
+lean_ctor_set(x_613, 3, x_611);
+lean_ctor_set_uint8(x_613, sizeof(void*)*4, x_612);
+return x_613;
+}
+}
+else
+{
+uint8_t x_614; 
+x_614 = !lean_is_exclusive(x_242);
+if (x_614 == 0)
+{
+lean_object* x_615; lean_object* x_616; lean_object* x_617; lean_object* x_618; 
+x_615 = lean_ctor_get(x_242, 3);
+lean_dec(x_615);
+x_616 = lean_ctor_get(x_242, 2);
+lean_dec(x_616);
+x_617 = lean_ctor_get(x_242, 1);
+lean_dec(x_617);
+x_618 = lean_ctor_get(x_242, 0);
+lean_dec(x_618);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_619; 
+x_619 = 1;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_3);
+lean_ctor_set(x_242, 1, x_2);
+lean_ctor_set(x_242, 0, x_1);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_619);
+return x_242;
+}
+else
+{
+uint8_t x_620; 
+x_620 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_620 == 0)
+{
+lean_object* x_621; 
+x_621 = lean_ctor_get(x_4, 0);
+lean_inc(x_621);
+if (lean_obj_tag(x_621) == 0)
+{
+lean_object* x_622; 
+x_622 = lean_ctor_get(x_4, 3);
+lean_inc(x_622);
+if (lean_obj_tag(x_622) == 0)
+{
+uint8_t x_623; 
+x_623 = 1;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_3);
+lean_ctor_set(x_242, 1, x_2);
+lean_ctor_set(x_242, 0, x_1);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_623);
+return x_242;
+}
+else
+{
+uint8_t x_624; 
+x_624 = lean_ctor_get_uint8(x_622, sizeof(void*)*4);
+if (x_624 == 0)
+{
+uint8_t x_625; 
+x_625 = !lean_is_exclusive(x_4);
+if (x_625 == 0)
+{
+lean_object* x_626; lean_object* x_627; lean_object* x_628; lean_object* x_629; uint8_t x_630; 
+x_626 = lean_ctor_get(x_4, 1);
+x_627 = lean_ctor_get(x_4, 2);
+x_628 = lean_ctor_get(x_4, 3);
+lean_dec(x_628);
+x_629 = lean_ctor_get(x_4, 0);
+lean_dec(x_629);
+x_630 = !lean_is_exclusive(x_622);
+if (x_630 == 0)
+{
+lean_object* x_631; lean_object* x_632; lean_object* x_633; lean_object* x_634; uint8_t x_635; uint8_t x_636; 
+x_631 = lean_ctor_get(x_622, 0);
+x_632 = lean_ctor_get(x_622, 1);
+x_633 = lean_ctor_get(x_622, 2);
+x_634 = lean_ctor_get(x_622, 3);
+x_635 = 1;
+lean_ctor_set(x_622, 3, x_621);
+lean_ctor_set(x_622, 2, x_3);
+lean_ctor_set(x_622, 1, x_2);
+lean_ctor_set(x_622, 0, x_1);
+lean_ctor_set_uint8(x_622, sizeof(void*)*4, x_635);
+lean_ctor_set(x_4, 3, x_634);
+lean_ctor_set(x_4, 2, x_633);
+lean_ctor_set(x_4, 1, x_632);
+lean_ctor_set(x_4, 0, x_631);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_635);
+x_636 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_627);
+lean_ctor_set(x_242, 1, x_626);
+lean_ctor_set(x_242, 0, x_622);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_636);
+return x_242;
+}
+else
+{
+lean_object* x_637; lean_object* x_638; lean_object* x_639; lean_object* x_640; uint8_t x_641; lean_object* x_642; uint8_t x_643; 
+x_637 = lean_ctor_get(x_622, 0);
+x_638 = lean_ctor_get(x_622, 1);
+x_639 = lean_ctor_get(x_622, 2);
+x_640 = lean_ctor_get(x_622, 3);
+lean_inc(x_640);
+lean_inc(x_639);
+lean_inc(x_638);
+lean_inc(x_637);
+lean_dec(x_622);
+x_641 = 1;
+x_642 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_642, 0, x_1);
+lean_ctor_set(x_642, 1, x_2);
+lean_ctor_set(x_642, 2, x_3);
+lean_ctor_set(x_642, 3, x_621);
+lean_ctor_set_uint8(x_642, sizeof(void*)*4, x_641);
+lean_ctor_set(x_4, 3, x_640);
+lean_ctor_set(x_4, 2, x_639);
+lean_ctor_set(x_4, 1, x_638);
+lean_ctor_set(x_4, 0, x_637);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_641);
+x_643 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_627);
+lean_ctor_set(x_242, 1, x_626);
+lean_ctor_set(x_242, 0, x_642);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_643);
+return x_242;
+}
+}
+else
+{
+lean_object* x_644; lean_object* x_645; lean_object* x_646; lean_object* x_647; lean_object* x_648; lean_object* x_649; lean_object* x_650; uint8_t x_651; lean_object* x_652; lean_object* x_653; uint8_t x_654; 
+x_644 = lean_ctor_get(x_4, 1);
+x_645 = lean_ctor_get(x_4, 2);
+lean_inc(x_645);
+lean_inc(x_644);
+lean_dec(x_4);
+x_646 = lean_ctor_get(x_622, 0);
+lean_inc(x_646);
+x_647 = lean_ctor_get(x_622, 1);
+lean_inc(x_647);
+x_648 = lean_ctor_get(x_622, 2);
+lean_inc(x_648);
+x_649 = lean_ctor_get(x_622, 3);
+lean_inc(x_649);
+if (lean_is_exclusive(x_622)) {
+ lean_ctor_release(x_622, 0);
+ lean_ctor_release(x_622, 1);
+ lean_ctor_release(x_622, 2);
+ lean_ctor_release(x_622, 3);
+ x_650 = x_622;
+} else {
+ lean_dec_ref(x_622);
+ x_650 = lean_box(0);
+}
+x_651 = 1;
+if (lean_is_scalar(x_650)) {
+ x_652 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_652 = x_650;
+}
+lean_ctor_set(x_652, 0, x_1);
+lean_ctor_set(x_652, 1, x_2);
+lean_ctor_set(x_652, 2, x_3);
+lean_ctor_set(x_652, 3, x_621);
+lean_ctor_set_uint8(x_652, sizeof(void*)*4, x_651);
+x_653 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_653, 0, x_646);
+lean_ctor_set(x_653, 1, x_647);
+lean_ctor_set(x_653, 2, x_648);
+lean_ctor_set(x_653, 3, x_649);
+lean_ctor_set_uint8(x_653, sizeof(void*)*4, x_651);
+x_654 = 0;
+lean_ctor_set(x_242, 3, x_653);
+lean_ctor_set(x_242, 2, x_645);
+lean_ctor_set(x_242, 1, x_644);
+lean_ctor_set(x_242, 0, x_652);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_654);
+return x_242;
+}
+}
+else
+{
+uint8_t x_655; 
+lean_free_object(x_242);
+x_655 = !lean_is_exclusive(x_622);
+if (x_655 == 0)
+{
+lean_object* x_656; lean_object* x_657; lean_object* x_658; lean_object* x_659; uint8_t x_660; 
+x_656 = lean_ctor_get(x_622, 3);
+lean_dec(x_656);
+x_657 = lean_ctor_get(x_622, 2);
+lean_dec(x_657);
+x_658 = lean_ctor_get(x_622, 1);
+lean_dec(x_658);
+x_659 = lean_ctor_get(x_622, 0);
+lean_dec(x_659);
+x_660 = 1;
+lean_ctor_set(x_622, 3, x_4);
+lean_ctor_set(x_622, 2, x_3);
+lean_ctor_set(x_622, 1, x_2);
+lean_ctor_set(x_622, 0, x_1);
+lean_ctor_set_uint8(x_622, sizeof(void*)*4, x_660);
+return x_622;
+}
+else
+{
+uint8_t x_661; lean_object* x_662; 
+lean_dec(x_622);
+x_661 = 1;
+x_662 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_662, 0, x_1);
+lean_ctor_set(x_662, 1, x_2);
+lean_ctor_set(x_662, 2, x_3);
+lean_ctor_set(x_662, 3, x_4);
+lean_ctor_set_uint8(x_662, sizeof(void*)*4, x_661);
+return x_662;
+}
+}
+}
+}
+else
+{
+uint8_t x_663; 
+x_663 = lean_ctor_get_uint8(x_621, sizeof(void*)*4);
+if (x_663 == 0)
+{
+lean_object* x_664; 
+x_664 = lean_ctor_get(x_4, 3);
+lean_inc(x_664);
+if (lean_obj_tag(x_664) == 0)
+{
+uint8_t x_665; 
+x_665 = !lean_is_exclusive(x_4);
+if (x_665 == 0)
+{
+lean_object* x_666; lean_object* x_667; uint8_t x_668; 
+x_666 = lean_ctor_get(x_4, 3);
+lean_dec(x_666);
+x_667 = lean_ctor_get(x_4, 0);
+lean_dec(x_667);
+x_668 = !lean_is_exclusive(x_621);
+if (x_668 == 0)
+{
+lean_object* x_669; lean_object* x_670; lean_object* x_671; lean_object* x_672; uint8_t x_673; uint8_t x_674; 
+x_669 = lean_ctor_get(x_621, 0);
+x_670 = lean_ctor_get(x_621, 1);
+x_671 = lean_ctor_get(x_621, 2);
+x_672 = lean_ctor_get(x_621, 3);
+x_673 = 1;
+lean_ctor_set(x_621, 3, x_669);
+lean_ctor_set(x_621, 2, x_3);
+lean_ctor_set(x_621, 1, x_2);
+lean_ctor_set(x_621, 0, x_1);
+lean_ctor_set_uint8(x_621, sizeof(void*)*4, x_673);
+lean_ctor_set(x_4, 0, x_672);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_673);
+x_674 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_671);
+lean_ctor_set(x_242, 1, x_670);
+lean_ctor_set(x_242, 0, x_621);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_674);
+return x_242;
+}
+else
+{
+lean_object* x_675; lean_object* x_676; lean_object* x_677; lean_object* x_678; uint8_t x_679; lean_object* x_680; uint8_t x_681; 
+x_675 = lean_ctor_get(x_621, 0);
+x_676 = lean_ctor_get(x_621, 1);
+x_677 = lean_ctor_get(x_621, 2);
+x_678 = lean_ctor_get(x_621, 3);
+lean_inc(x_678);
+lean_inc(x_677);
+lean_inc(x_676);
+lean_inc(x_675);
+lean_dec(x_621);
+x_679 = 1;
+x_680 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_680, 0, x_1);
+lean_ctor_set(x_680, 1, x_2);
+lean_ctor_set(x_680, 2, x_3);
+lean_ctor_set(x_680, 3, x_675);
+lean_ctor_set_uint8(x_680, sizeof(void*)*4, x_679);
+lean_ctor_set(x_4, 0, x_678);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_679);
+x_681 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_677);
+lean_ctor_set(x_242, 1, x_676);
+lean_ctor_set(x_242, 0, x_680);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_681);
+return x_242;
+}
+}
+else
+{
+lean_object* x_682; lean_object* x_683; lean_object* x_684; lean_object* x_685; lean_object* x_686; lean_object* x_687; lean_object* x_688; uint8_t x_689; lean_object* x_690; lean_object* x_691; uint8_t x_692; 
+x_682 = lean_ctor_get(x_4, 1);
+x_683 = lean_ctor_get(x_4, 2);
+lean_inc(x_683);
+lean_inc(x_682);
+lean_dec(x_4);
+x_684 = lean_ctor_get(x_621, 0);
+lean_inc(x_684);
+x_685 = lean_ctor_get(x_621, 1);
+lean_inc(x_685);
+x_686 = lean_ctor_get(x_621, 2);
+lean_inc(x_686);
+x_687 = lean_ctor_get(x_621, 3);
+lean_inc(x_687);
+if (lean_is_exclusive(x_621)) {
+ lean_ctor_release(x_621, 0);
+ lean_ctor_release(x_621, 1);
+ lean_ctor_release(x_621, 2);
+ lean_ctor_release(x_621, 3);
+ x_688 = x_621;
+} else {
+ lean_dec_ref(x_621);
+ x_688 = lean_box(0);
+}
+x_689 = 1;
+if (lean_is_scalar(x_688)) {
+ x_690 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_690 = x_688;
+}
+lean_ctor_set(x_690, 0, x_1);
+lean_ctor_set(x_690, 1, x_2);
+lean_ctor_set(x_690, 2, x_3);
+lean_ctor_set(x_690, 3, x_684);
+lean_ctor_set_uint8(x_690, sizeof(void*)*4, x_689);
+x_691 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_691, 0, x_687);
+lean_ctor_set(x_691, 1, x_682);
+lean_ctor_set(x_691, 2, x_683);
+lean_ctor_set(x_691, 3, x_664);
+lean_ctor_set_uint8(x_691, sizeof(void*)*4, x_689);
+x_692 = 0;
+lean_ctor_set(x_242, 3, x_691);
+lean_ctor_set(x_242, 2, x_686);
+lean_ctor_set(x_242, 1, x_685);
+lean_ctor_set(x_242, 0, x_690);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_692);
+return x_242;
+}
+}
+else
+{
+uint8_t x_693; 
+x_693 = lean_ctor_get_uint8(x_664, sizeof(void*)*4);
+if (x_693 == 0)
+{
+uint8_t x_694; 
+x_694 = !lean_is_exclusive(x_4);
+if (x_694 == 0)
+{
+lean_object* x_695; lean_object* x_696; lean_object* x_697; lean_object* x_698; uint8_t x_699; 
+x_695 = lean_ctor_get(x_4, 1);
+x_696 = lean_ctor_get(x_4, 2);
+x_697 = lean_ctor_get(x_4, 3);
+lean_dec(x_697);
+x_698 = lean_ctor_get(x_4, 0);
+lean_dec(x_698);
+x_699 = !lean_is_exclusive(x_621);
+if (x_699 == 0)
+{
+uint8_t x_700; 
+x_700 = !lean_is_exclusive(x_664);
+if (x_700 == 0)
+{
+lean_object* x_701; lean_object* x_702; lean_object* x_703; lean_object* x_704; lean_object* x_705; lean_object* x_706; lean_object* x_707; lean_object* x_708; uint8_t x_709; uint8_t x_710; 
+x_701 = lean_ctor_get(x_621, 0);
+x_702 = lean_ctor_get(x_621, 1);
+x_703 = lean_ctor_get(x_621, 2);
+x_704 = lean_ctor_get(x_621, 3);
+x_705 = lean_ctor_get(x_664, 0);
+x_706 = lean_ctor_get(x_664, 1);
+x_707 = lean_ctor_get(x_664, 2);
+x_708 = lean_ctor_get(x_664, 3);
+lean_ctor_set(x_664, 3, x_704);
+lean_ctor_set(x_664, 2, x_703);
+lean_ctor_set(x_664, 1, x_702);
+lean_ctor_set(x_664, 0, x_701);
+x_709 = 1;
+lean_ctor_set(x_621, 3, x_664);
+lean_ctor_set(x_621, 2, x_3);
+lean_ctor_set(x_621, 1, x_2);
+lean_ctor_set(x_621, 0, x_1);
+lean_ctor_set_uint8(x_621, sizeof(void*)*4, x_709);
+lean_ctor_set(x_4, 3, x_708);
+lean_ctor_set(x_4, 2, x_707);
+lean_ctor_set(x_4, 1, x_706);
+lean_ctor_set(x_4, 0, x_705);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_709);
+x_710 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_696);
+lean_ctor_set(x_242, 1, x_695);
+lean_ctor_set(x_242, 0, x_621);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_710);
+return x_242;
+}
+else
+{
+lean_object* x_711; lean_object* x_712; lean_object* x_713; lean_object* x_714; lean_object* x_715; lean_object* x_716; lean_object* x_717; lean_object* x_718; lean_object* x_719; uint8_t x_720; uint8_t x_721; 
+x_711 = lean_ctor_get(x_621, 0);
+x_712 = lean_ctor_get(x_621, 1);
+x_713 = lean_ctor_get(x_621, 2);
+x_714 = lean_ctor_get(x_621, 3);
+x_715 = lean_ctor_get(x_664, 0);
+x_716 = lean_ctor_get(x_664, 1);
+x_717 = lean_ctor_get(x_664, 2);
+x_718 = lean_ctor_get(x_664, 3);
+lean_inc(x_718);
+lean_inc(x_717);
+lean_inc(x_716);
+lean_inc(x_715);
+lean_dec(x_664);
+x_719 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_719, 0, x_711);
+lean_ctor_set(x_719, 1, x_712);
+lean_ctor_set(x_719, 2, x_713);
+lean_ctor_set(x_719, 3, x_714);
+lean_ctor_set_uint8(x_719, sizeof(void*)*4, x_693);
+x_720 = 1;
+lean_ctor_set(x_621, 3, x_719);
+lean_ctor_set(x_621, 2, x_3);
+lean_ctor_set(x_621, 1, x_2);
+lean_ctor_set(x_621, 0, x_1);
+lean_ctor_set_uint8(x_621, sizeof(void*)*4, x_720);
+lean_ctor_set(x_4, 3, x_718);
+lean_ctor_set(x_4, 2, x_717);
+lean_ctor_set(x_4, 1, x_716);
+lean_ctor_set(x_4, 0, x_715);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_720);
+x_721 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_696);
+lean_ctor_set(x_242, 1, x_695);
+lean_ctor_set(x_242, 0, x_621);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_721);
+return x_242;
+}
+}
+else
+{
+lean_object* x_722; lean_object* x_723; lean_object* x_724; lean_object* x_725; lean_object* x_726; lean_object* x_727; lean_object* x_728; lean_object* x_729; lean_object* x_730; lean_object* x_731; uint8_t x_732; lean_object* x_733; uint8_t x_734; 
+x_722 = lean_ctor_get(x_621, 0);
+x_723 = lean_ctor_get(x_621, 1);
+x_724 = lean_ctor_get(x_621, 2);
+x_725 = lean_ctor_get(x_621, 3);
+lean_inc(x_725);
+lean_inc(x_724);
+lean_inc(x_723);
+lean_inc(x_722);
+lean_dec(x_621);
+x_726 = lean_ctor_get(x_664, 0);
+lean_inc(x_726);
+x_727 = lean_ctor_get(x_664, 1);
+lean_inc(x_727);
+x_728 = lean_ctor_get(x_664, 2);
+lean_inc(x_728);
+x_729 = lean_ctor_get(x_664, 3);
+lean_inc(x_729);
+if (lean_is_exclusive(x_664)) {
+ lean_ctor_release(x_664, 0);
+ lean_ctor_release(x_664, 1);
+ lean_ctor_release(x_664, 2);
+ lean_ctor_release(x_664, 3);
+ x_730 = x_664;
+} else {
+ lean_dec_ref(x_664);
+ x_730 = lean_box(0);
+}
+if (lean_is_scalar(x_730)) {
+ x_731 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_731 = x_730;
+}
+lean_ctor_set(x_731, 0, x_722);
+lean_ctor_set(x_731, 1, x_723);
+lean_ctor_set(x_731, 2, x_724);
+lean_ctor_set(x_731, 3, x_725);
+lean_ctor_set_uint8(x_731, sizeof(void*)*4, x_693);
+x_732 = 1;
+x_733 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_733, 0, x_1);
+lean_ctor_set(x_733, 1, x_2);
+lean_ctor_set(x_733, 2, x_3);
+lean_ctor_set(x_733, 3, x_731);
+lean_ctor_set_uint8(x_733, sizeof(void*)*4, x_732);
+lean_ctor_set(x_4, 3, x_729);
+lean_ctor_set(x_4, 2, x_728);
+lean_ctor_set(x_4, 1, x_727);
+lean_ctor_set(x_4, 0, x_726);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_732);
+x_734 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_696);
+lean_ctor_set(x_242, 1, x_695);
+lean_ctor_set(x_242, 0, x_733);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_734);
+return x_242;
+}
+}
+else
+{
+lean_object* x_735; lean_object* x_736; lean_object* x_737; lean_object* x_738; lean_object* x_739; lean_object* x_740; lean_object* x_741; lean_object* x_742; lean_object* x_743; lean_object* x_744; lean_object* x_745; lean_object* x_746; lean_object* x_747; uint8_t x_748; lean_object* x_749; lean_object* x_750; uint8_t x_751; 
+x_735 = lean_ctor_get(x_4, 1);
+x_736 = lean_ctor_get(x_4, 2);
 lean_inc(x_736);
 lean_inc(x_735);
-lean_inc(x_734);
-lean_inc(x_733);
-lean_dec(x_680);
-lean_inc(x_235);
-x_737 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_737, 0, x_679);
-lean_ctor_set(x_737, 1, x_713);
-lean_ctor_set(x_737, 2, x_714);
-lean_ctor_set(x_737, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_738 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_738 = lean_box(0);
-}
-lean_ctor_set_uint8(x_737, sizeof(void*)*4, x_711);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_737);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_738)) {
- x_739 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_739 = x_738;
-}
-lean_ctor_set(x_739, 0, x_733);
-lean_ctor_set(x_739, 1, x_734);
-lean_ctor_set(x_739, 2, x_735);
-lean_ctor_set(x_739, 3, x_736);
-lean_ctor_set_uint8(x_739, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_739);
-lean_ctor_set(x_1, 2, x_719);
-lean_ctor_set(x_1, 1, x_718);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_711);
-return x_1;
-}
-}
-else
-{
-lean_object* x_740; lean_object* x_741; lean_object* x_742; lean_object* x_743; lean_object* x_744; lean_object* x_745; lean_object* x_746; lean_object* x_747; lean_object* x_748; lean_object* x_749; lean_object* x_750; 
-x_740 = lean_ctor_get(x_4, 1);
-x_741 = lean_ctor_get(x_4, 2);
-lean_inc(x_741);
-lean_inc(x_740);
 lean_dec(x_4);
-x_742 = lean_ctor_get(x_680, 0);
-lean_inc(x_742);
-x_743 = lean_ctor_get(x_680, 1);
-lean_inc(x_743);
-x_744 = lean_ctor_get(x_680, 2);
-lean_inc(x_744);
-x_745 = lean_ctor_get(x_680, 3);
-lean_inc(x_745);
-if (lean_is_exclusive(x_680)) {
- lean_ctor_release(x_680, 0);
- lean_ctor_release(x_680, 1);
- lean_ctor_release(x_680, 2);
- lean_ctor_release(x_680, 3);
- x_746 = x_680;
+x_737 = lean_ctor_get(x_621, 0);
+lean_inc(x_737);
+x_738 = lean_ctor_get(x_621, 1);
+lean_inc(x_738);
+x_739 = lean_ctor_get(x_621, 2);
+lean_inc(x_739);
+x_740 = lean_ctor_get(x_621, 3);
+lean_inc(x_740);
+if (lean_is_exclusive(x_621)) {
+ lean_ctor_release(x_621, 0);
+ lean_ctor_release(x_621, 1);
+ lean_ctor_release(x_621, 2);
+ lean_ctor_release(x_621, 3);
+ x_741 = x_621;
 } else {
- lean_dec_ref(x_680);
+ lean_dec_ref(x_621);
+ x_741 = lean_box(0);
+}
+x_742 = lean_ctor_get(x_664, 0);
+lean_inc(x_742);
+x_743 = lean_ctor_get(x_664, 1);
+lean_inc(x_743);
+x_744 = lean_ctor_get(x_664, 2);
+lean_inc(x_744);
+x_745 = lean_ctor_get(x_664, 3);
+lean_inc(x_745);
+if (lean_is_exclusive(x_664)) {
+ lean_ctor_release(x_664, 0);
+ lean_ctor_release(x_664, 1);
+ lean_ctor_release(x_664, 2);
+ lean_ctor_release(x_664, 3);
+ x_746 = x_664;
+} else {
+ lean_dec_ref(x_664);
  x_746 = lean_box(0);
 }
-lean_inc(x_235);
 if (lean_is_scalar(x_746)) {
  x_747 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_747 = x_746;
 }
-lean_ctor_set(x_747, 0, x_679);
-lean_ctor_set(x_747, 1, x_713);
-lean_ctor_set(x_747, 2, x_714);
-lean_ctor_set(x_747, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_748 = x_235;
+lean_ctor_set(x_747, 0, x_737);
+lean_ctor_set(x_747, 1, x_738);
+lean_ctor_set(x_747, 2, x_739);
+lean_ctor_set(x_747, 3, x_740);
+lean_ctor_set_uint8(x_747, sizeof(void*)*4, x_693);
+x_748 = 1;
+if (lean_is_scalar(x_741)) {
+ x_749 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_235);
- x_748 = lean_box(0);
+ x_749 = x_741;
 }
-lean_ctor_set_uint8(x_747, sizeof(void*)*4, x_711);
-x_749 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_749, 0, x_747);
+lean_ctor_set(x_749, 0, x_1);
 lean_ctor_set(x_749, 1, x_2);
 lean_ctor_set(x_749, 2, x_3);
-lean_ctor_set(x_749, 3, x_679);
-lean_ctor_set_uint8(x_749, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_748)) {
- x_750 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_750 = x_748;
-}
+lean_ctor_set(x_749, 3, x_747);
+lean_ctor_set_uint8(x_749, sizeof(void*)*4, x_748);
+x_750 = lean_alloc_ctor(1, 4, 1);
 lean_ctor_set(x_750, 0, x_742);
 lean_ctor_set(x_750, 1, x_743);
 lean_ctor_set(x_750, 2, x_744);
 lean_ctor_set(x_750, 3, x_745);
-lean_ctor_set_uint8(x_750, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_750);
-lean_ctor_set(x_1, 2, x_741);
-lean_ctor_set(x_1, 1, x_740);
-lean_ctor_set(x_1, 0, x_749);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_711);
-return x_1;
+lean_ctor_set_uint8(x_750, sizeof(void*)*4, x_748);
+x_751 = 0;
+lean_ctor_set(x_242, 3, x_750);
+lean_ctor_set(x_242, 2, x_736);
+lean_ctor_set(x_242, 1, x_735);
+lean_ctor_set(x_242, 0, x_749);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_751);
+return x_242;
 }
 }
 else
 {
-lean_object* x_751; lean_object* x_752; lean_object* x_753; lean_object* x_754; lean_object* x_755; lean_object* x_756; lean_object* x_757; lean_object* x_758; lean_object* x_759; lean_object* x_760; lean_object* x_761; lean_object* x_762; lean_object* x_763; lean_object* x_764; lean_object* x_765; 
-x_751 = lean_ctor_get(x_1, 1);
-x_752 = lean_ctor_get(x_1, 2);
-lean_inc(x_752);
-lean_inc(x_751);
-lean_dec(x_1);
-x_753 = lean_ctor_get(x_4, 1);
-lean_inc(x_753);
-x_754 = lean_ctor_get(x_4, 2);
-lean_inc(x_754);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_755 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_755 = lean_box(0);
+uint8_t x_752; 
+x_752 = !lean_is_exclusive(x_4);
+if (x_752 == 0)
+{
+lean_object* x_753; lean_object* x_754; uint8_t x_755; 
+x_753 = lean_ctor_get(x_4, 3);
+lean_dec(x_753);
+x_754 = lean_ctor_get(x_4, 0);
+lean_dec(x_754);
+x_755 = !lean_is_exclusive(x_621);
+if (x_755 == 0)
+{
+lean_object* x_756; lean_object* x_757; lean_object* x_758; lean_object* x_759; uint8_t x_760; uint8_t x_761; 
+x_756 = lean_ctor_get(x_621, 0);
+x_757 = lean_ctor_get(x_621, 1);
+x_758 = lean_ctor_get(x_621, 2);
+x_759 = lean_ctor_get(x_621, 3);
+x_760 = 1;
+lean_ctor_set(x_621, 3, x_756);
+lean_ctor_set(x_621, 2, x_3);
+lean_ctor_set(x_621, 1, x_2);
+lean_ctor_set(x_621, 0, x_1);
+lean_ctor_set_uint8(x_621, sizeof(void*)*4, x_760);
+lean_ctor_set(x_4, 0, x_759);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_760);
+x_761 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_758);
+lean_ctor_set(x_242, 1, x_757);
+lean_ctor_set(x_242, 0, x_621);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_761);
+return x_242;
 }
-x_756 = lean_ctor_get(x_680, 0);
-lean_inc(x_756);
-x_757 = lean_ctor_get(x_680, 1);
-lean_inc(x_757);
-x_758 = lean_ctor_get(x_680, 2);
-lean_inc(x_758);
-x_759 = lean_ctor_get(x_680, 3);
-lean_inc(x_759);
-if (lean_is_exclusive(x_680)) {
- lean_ctor_release(x_680, 0);
- lean_ctor_release(x_680, 1);
- lean_ctor_release(x_680, 2);
- lean_ctor_release(x_680, 3);
- x_760 = x_680;
-} else {
- lean_dec_ref(x_680);
- x_760 = lean_box(0);
-}
-lean_inc(x_235);
-if (lean_is_scalar(x_760)) {
- x_761 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_761 = x_760;
-}
-lean_ctor_set(x_761, 0, x_679);
-lean_ctor_set(x_761, 1, x_751);
-lean_ctor_set(x_761, 2, x_752);
-lean_ctor_set(x_761, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_762 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_762 = lean_box(0);
-}
-lean_ctor_set_uint8(x_761, sizeof(void*)*4, x_711);
-if (lean_is_scalar(x_755)) {
- x_763 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_763 = x_755;
-}
-lean_ctor_set(x_763, 0, x_761);
-lean_ctor_set(x_763, 1, x_2);
-lean_ctor_set(x_763, 2, x_3);
-lean_ctor_set(x_763, 3, x_679);
-lean_ctor_set_uint8(x_763, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_762)) {
- x_764 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_764 = x_762;
-}
-lean_ctor_set(x_764, 0, x_756);
-lean_ctor_set(x_764, 1, x_757);
-lean_ctor_set(x_764, 2, x_758);
-lean_ctor_set(x_764, 3, x_759);
-lean_ctor_set_uint8(x_764, sizeof(void*)*4, x_639);
-x_765 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_765, 0, x_763);
-lean_ctor_set(x_765, 1, x_753);
-lean_ctor_set(x_765, 2, x_754);
-lean_ctor_set(x_765, 3, x_764);
-lean_ctor_set_uint8(x_765, sizeof(void*)*4, x_711);
-return x_765;
+else
+{
+lean_object* x_762; lean_object* x_763; lean_object* x_764; lean_object* x_765; uint8_t x_766; lean_object* x_767; uint8_t x_768; 
+x_762 = lean_ctor_get(x_621, 0);
+x_763 = lean_ctor_get(x_621, 1);
+x_764 = lean_ctor_get(x_621, 2);
+x_765 = lean_ctor_get(x_621, 3);
+lean_inc(x_765);
+lean_inc(x_764);
+lean_inc(x_763);
+lean_inc(x_762);
+lean_dec(x_621);
+x_766 = 1;
+x_767 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_767, 0, x_1);
+lean_ctor_set(x_767, 1, x_2);
+lean_ctor_set(x_767, 2, x_3);
+lean_ctor_set(x_767, 3, x_762);
+lean_ctor_set_uint8(x_767, sizeof(void*)*4, x_766);
+lean_ctor_set(x_4, 0, x_765);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_766);
+x_768 = 0;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_764);
+lean_ctor_set(x_242, 1, x_763);
+lean_ctor_set(x_242, 0, x_767);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_768);
+return x_242;
 }
 }
 else
 {
-uint8_t x_766; 
-x_766 = !lean_is_exclusive(x_680);
-if (x_766 == 0)
-{
-lean_object* x_767; lean_object* x_768; lean_object* x_769; lean_object* x_770; uint8_t x_771; 
-x_767 = lean_ctor_get(x_680, 3);
-lean_dec(x_767);
-x_768 = lean_ctor_get(x_680, 2);
-lean_dec(x_768);
-x_769 = lean_ctor_get(x_680, 1);
-lean_dec(x_769);
-x_770 = lean_ctor_get(x_680, 0);
-lean_dec(x_770);
-x_771 = !lean_is_exclusive(x_1);
-if (x_771 == 0)
-{
-lean_object* x_772; lean_object* x_773; lean_object* x_774; lean_object* x_775; uint8_t x_776; 
-x_772 = lean_ctor_get(x_1, 1);
-x_773 = lean_ctor_get(x_1, 2);
-x_774 = lean_ctor_get(x_1, 3);
-lean_dec(x_774);
-x_775 = lean_ctor_get(x_1, 0);
-lean_dec(x_775);
-x_776 = !lean_is_exclusive(x_235);
-if (x_776 == 0)
-{
-lean_object* x_777; lean_object* x_778; lean_object* x_779; lean_object* x_780; 
-x_777 = lean_ctor_get(x_235, 0);
-x_778 = lean_ctor_get(x_235, 1);
-x_779 = lean_ctor_get(x_235, 2);
-x_780 = lean_ctor_get(x_235, 3);
-lean_ctor_set(x_680, 3, x_780);
-lean_ctor_set(x_680, 2, x_779);
-lean_ctor_set(x_680, 1, x_778);
-lean_ctor_set(x_680, 0, x_777);
-lean_ctor_set(x_235, 3, x_680);
-lean_ctor_set(x_235, 2, x_773);
-lean_ctor_set(x_235, 1, x_772);
-lean_ctor_set(x_235, 0, x_679);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_235);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_711);
-return x_1;
-}
-else
-{
-lean_object* x_781; lean_object* x_782; lean_object* x_783; lean_object* x_784; lean_object* x_785; 
-x_781 = lean_ctor_get(x_235, 0);
-x_782 = lean_ctor_get(x_235, 1);
-x_783 = lean_ctor_get(x_235, 2);
-x_784 = lean_ctor_get(x_235, 3);
-lean_inc(x_784);
-lean_inc(x_783);
-lean_inc(x_782);
-lean_inc(x_781);
-lean_dec(x_235);
-lean_ctor_set(x_680, 3, x_784);
-lean_ctor_set(x_680, 2, x_783);
-lean_ctor_set(x_680, 1, x_782);
-lean_ctor_set(x_680, 0, x_781);
-x_785 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_785, 0, x_679);
-lean_ctor_set(x_785, 1, x_772);
-lean_ctor_set(x_785, 2, x_773);
-lean_ctor_set(x_785, 3, x_680);
-lean_ctor_set_uint8(x_785, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_785);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_711);
-return x_1;
-}
-}
-else
-{
-lean_object* x_786; lean_object* x_787; lean_object* x_788; lean_object* x_789; lean_object* x_790; lean_object* x_791; lean_object* x_792; lean_object* x_793; lean_object* x_794; 
-x_786 = lean_ctor_get(x_1, 1);
-x_787 = lean_ctor_get(x_1, 2);
-lean_inc(x_787);
-lean_inc(x_786);
-lean_dec(x_1);
-x_788 = lean_ctor_get(x_235, 0);
-lean_inc(x_788);
-x_789 = lean_ctor_get(x_235, 1);
-lean_inc(x_789);
-x_790 = lean_ctor_get(x_235, 2);
-lean_inc(x_790);
-x_791 = lean_ctor_get(x_235, 3);
-lean_inc(x_791);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_792 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_792 = lean_box(0);
-}
-lean_ctor_set(x_680, 3, x_791);
-lean_ctor_set(x_680, 2, x_790);
-lean_ctor_set(x_680, 1, x_789);
-lean_ctor_set(x_680, 0, x_788);
-if (lean_is_scalar(x_792)) {
- x_793 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_793 = x_792;
-}
-lean_ctor_set(x_793, 0, x_679);
-lean_ctor_set(x_793, 1, x_786);
-lean_ctor_set(x_793, 2, x_787);
-lean_ctor_set(x_793, 3, x_680);
-lean_ctor_set_uint8(x_793, sizeof(void*)*4, x_678);
-x_794 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_794, 0, x_793);
-lean_ctor_set(x_794, 1, x_2);
-lean_ctor_set(x_794, 2, x_3);
-lean_ctor_set(x_794, 3, x_4);
-lean_ctor_set_uint8(x_794, sizeof(void*)*4, x_711);
-return x_794;
-}
-}
-else
-{
-lean_object* x_795; lean_object* x_796; lean_object* x_797; lean_object* x_798; lean_object* x_799; lean_object* x_800; lean_object* x_801; lean_object* x_802; lean_object* x_803; lean_object* x_804; lean_object* x_805; 
-lean_dec(x_680);
-x_795 = lean_ctor_get(x_1, 1);
-lean_inc(x_795);
-x_796 = lean_ctor_get(x_1, 2);
-lean_inc(x_796);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_797 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_797 = lean_box(0);
-}
-x_798 = lean_ctor_get(x_235, 0);
-lean_inc(x_798);
-x_799 = lean_ctor_get(x_235, 1);
-lean_inc(x_799);
-x_800 = lean_ctor_get(x_235, 2);
-lean_inc(x_800);
-x_801 = lean_ctor_get(x_235, 3);
-lean_inc(x_801);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_802 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_802 = lean_box(0);
-}
-x_803 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_803, 0, x_798);
-lean_ctor_set(x_803, 1, x_799);
-lean_ctor_set(x_803, 2, x_800);
-lean_ctor_set(x_803, 3, x_801);
-lean_ctor_set_uint8(x_803, sizeof(void*)*4, x_711);
-if (lean_is_scalar(x_802)) {
- x_804 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_804 = x_802;
-}
-lean_ctor_set(x_804, 0, x_679);
-lean_ctor_set(x_804, 1, x_795);
-lean_ctor_set(x_804, 2, x_796);
-lean_ctor_set(x_804, 3, x_803);
-lean_ctor_set_uint8(x_804, sizeof(void*)*4, x_678);
-if (lean_is_scalar(x_797)) {
- x_805 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_805 = x_797;
-}
-lean_ctor_set(x_805, 0, x_804);
-lean_ctor_set(x_805, 1, x_2);
-lean_ctor_set(x_805, 2, x_3);
-lean_ctor_set(x_805, 3, x_4);
-lean_ctor_set_uint8(x_805, sizeof(void*)*4, x_711);
-return x_805;
-}
-}
-}
-}
-else
-{
-uint8_t x_806; 
-x_806 = lean_ctor_get_uint8(x_679, sizeof(void*)*4);
-if (x_806 == 0)
-{
-lean_object* x_807; 
-x_807 = lean_ctor_get(x_4, 3);
-lean_inc(x_807);
-if (lean_obj_tag(x_807) == 0)
-{
-uint8_t x_808; 
-x_808 = !lean_is_exclusive(x_1);
-if (x_808 == 0)
-{
-lean_object* x_809; lean_object* x_810; lean_object* x_811; lean_object* x_812; uint8_t x_813; 
-x_809 = lean_ctor_get(x_1, 1);
-x_810 = lean_ctor_get(x_1, 2);
-x_811 = lean_ctor_get(x_1, 3);
-lean_dec(x_811);
-x_812 = lean_ctor_get(x_1, 0);
-lean_dec(x_812);
-x_813 = !lean_is_exclusive(x_4);
-if (x_813 == 0)
-{
-lean_object* x_814; lean_object* x_815; lean_object* x_816; lean_object* x_817; uint8_t x_818; 
-x_814 = lean_ctor_get(x_4, 1);
-x_815 = lean_ctor_get(x_4, 2);
-x_816 = lean_ctor_get(x_4, 3);
-lean_dec(x_816);
-x_817 = lean_ctor_get(x_4, 0);
-lean_dec(x_817);
-x_818 = !lean_is_exclusive(x_679);
-if (x_818 == 0)
-{
-lean_object* x_819; lean_object* x_820; lean_object* x_821; lean_object* x_822; uint8_t x_823; 
-x_819 = lean_ctor_get(x_679, 0);
-x_820 = lean_ctor_get(x_679, 1);
-x_821 = lean_ctor_get(x_679, 2);
-x_822 = lean_ctor_get(x_679, 3);
-lean_inc(x_235);
-lean_ctor_set(x_679, 3, x_235);
-lean_ctor_set(x_679, 2, x_810);
-lean_ctor_set(x_679, 1, x_809);
-lean_ctor_set(x_679, 0, x_807);
-x_823 = !lean_is_exclusive(x_235);
-if (x_823 == 0)
-{
-lean_object* x_824; lean_object* x_825; lean_object* x_826; lean_object* x_827; 
-x_824 = lean_ctor_get(x_235, 3);
-lean_dec(x_824);
-x_825 = lean_ctor_get(x_235, 2);
-lean_dec(x_825);
-x_826 = lean_ctor_get(x_235, 1);
-lean_dec(x_826);
-x_827 = lean_ctor_get(x_235, 0);
-lean_dec(x_827);
-lean_ctor_set(x_4, 3, x_819);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-lean_ctor_set(x_235, 3, x_807);
-lean_ctor_set(x_235, 2, x_815);
-lean_ctor_set(x_235, 1, x_814);
-lean_ctor_set(x_235, 0, x_822);
-lean_ctor_set(x_1, 2, x_821);
-lean_ctor_set(x_1, 1, x_820);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-return x_1;
-}
-else
-{
-lean_object* x_828; 
-lean_dec(x_235);
-lean_ctor_set(x_4, 3, x_819);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-x_828 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_828, 0, x_822);
-lean_ctor_set(x_828, 1, x_814);
-lean_ctor_set(x_828, 2, x_815);
-lean_ctor_set(x_828, 3, x_807);
-lean_ctor_set_uint8(x_828, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_828);
-lean_ctor_set(x_1, 2, x_821);
-lean_ctor_set(x_1, 1, x_820);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-return x_1;
-}
-}
-else
-{
-lean_object* x_829; lean_object* x_830; lean_object* x_831; lean_object* x_832; lean_object* x_833; lean_object* x_834; lean_object* x_835; 
-x_829 = lean_ctor_get(x_679, 0);
-x_830 = lean_ctor_get(x_679, 1);
-x_831 = lean_ctor_get(x_679, 2);
-x_832 = lean_ctor_get(x_679, 3);
-lean_inc(x_832);
-lean_inc(x_831);
-lean_inc(x_830);
-lean_inc(x_829);
-lean_dec(x_679);
-lean_inc(x_235);
-x_833 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_833, 0, x_807);
-lean_ctor_set(x_833, 1, x_809);
-lean_ctor_set(x_833, 2, x_810);
-lean_ctor_set(x_833, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_834 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_834 = lean_box(0);
-}
-lean_ctor_set_uint8(x_833, sizeof(void*)*4, x_806);
-lean_ctor_set(x_4, 3, x_829);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_833);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_834)) {
- x_835 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_835 = x_834;
-}
-lean_ctor_set(x_835, 0, x_832);
-lean_ctor_set(x_835, 1, x_814);
-lean_ctor_set(x_835, 2, x_815);
-lean_ctor_set(x_835, 3, x_807);
-lean_ctor_set_uint8(x_835, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_835);
-lean_ctor_set(x_1, 2, x_831);
-lean_ctor_set(x_1, 1, x_830);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-return x_1;
-}
-}
-else
-{
-lean_object* x_836; lean_object* x_837; lean_object* x_838; lean_object* x_839; lean_object* x_840; lean_object* x_841; lean_object* x_842; lean_object* x_843; lean_object* x_844; lean_object* x_845; lean_object* x_846; 
-x_836 = lean_ctor_get(x_4, 1);
-x_837 = lean_ctor_get(x_4, 2);
-lean_inc(x_837);
-lean_inc(x_836);
+lean_object* x_769; lean_object* x_770; lean_object* x_771; lean_object* x_772; lean_object* x_773; lean_object* x_774; lean_object* x_775; uint8_t x_776; lean_object* x_777; lean_object* x_778; uint8_t x_779; 
+x_769 = lean_ctor_get(x_4, 1);
+x_770 = lean_ctor_get(x_4, 2);
+lean_inc(x_770);
+lean_inc(x_769);
 lean_dec(x_4);
-x_838 = lean_ctor_get(x_679, 0);
-lean_inc(x_838);
-x_839 = lean_ctor_get(x_679, 1);
-lean_inc(x_839);
-x_840 = lean_ctor_get(x_679, 2);
-lean_inc(x_840);
-x_841 = lean_ctor_get(x_679, 3);
-lean_inc(x_841);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_842 = x_679;
+x_771 = lean_ctor_get(x_621, 0);
+lean_inc(x_771);
+x_772 = lean_ctor_get(x_621, 1);
+lean_inc(x_772);
+x_773 = lean_ctor_get(x_621, 2);
+lean_inc(x_773);
+x_774 = lean_ctor_get(x_621, 3);
+lean_inc(x_774);
+if (lean_is_exclusive(x_621)) {
+ lean_ctor_release(x_621, 0);
+ lean_ctor_release(x_621, 1);
+ lean_ctor_release(x_621, 2);
+ lean_ctor_release(x_621, 3);
+ x_775 = x_621;
 } else {
- lean_dec_ref(x_679);
- x_842 = lean_box(0);
+ lean_dec_ref(x_621);
+ x_775 = lean_box(0);
 }
-lean_inc(x_235);
-if (lean_is_scalar(x_842)) {
- x_843 = lean_alloc_ctor(1, 4, 1);
+x_776 = 1;
+if (lean_is_scalar(x_775)) {
+ x_777 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_843 = x_842;
+ x_777 = x_775;
 }
-lean_ctor_set(x_843, 0, x_807);
-lean_ctor_set(x_843, 1, x_809);
-lean_ctor_set(x_843, 2, x_810);
-lean_ctor_set(x_843, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_844 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_844 = lean_box(0);
+lean_ctor_set(x_777, 0, x_1);
+lean_ctor_set(x_777, 1, x_2);
+lean_ctor_set(x_777, 2, x_3);
+lean_ctor_set(x_777, 3, x_771);
+lean_ctor_set_uint8(x_777, sizeof(void*)*4, x_776);
+x_778 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_778, 0, x_774);
+lean_ctor_set(x_778, 1, x_769);
+lean_ctor_set(x_778, 2, x_770);
+lean_ctor_set(x_778, 3, x_664);
+lean_ctor_set_uint8(x_778, sizeof(void*)*4, x_776);
+x_779 = 0;
+lean_ctor_set(x_242, 3, x_778);
+lean_ctor_set(x_242, 2, x_773);
+lean_ctor_set(x_242, 1, x_772);
+lean_ctor_set(x_242, 0, x_777);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_779);
+return x_242;
 }
-lean_ctor_set_uint8(x_843, sizeof(void*)*4, x_806);
-x_845 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_845, 0, x_843);
-lean_ctor_set(x_845, 1, x_2);
-lean_ctor_set(x_845, 2, x_3);
-lean_ctor_set(x_845, 3, x_838);
-lean_ctor_set_uint8(x_845, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_844)) {
- x_846 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_846 = x_844;
 }
-lean_ctor_set(x_846, 0, x_841);
-lean_ctor_set(x_846, 1, x_836);
-lean_ctor_set(x_846, 2, x_837);
-lean_ctor_set(x_846, 3, x_807);
-lean_ctor_set_uint8(x_846, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_846);
-lean_ctor_set(x_1, 2, x_840);
-lean_ctor_set(x_1, 1, x_839);
-lean_ctor_set(x_1, 0, x_845);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-return x_1;
 }
 }
 else
 {
-lean_object* x_847; lean_object* x_848; lean_object* x_849; lean_object* x_850; lean_object* x_851; lean_object* x_852; lean_object* x_853; lean_object* x_854; lean_object* x_855; lean_object* x_856; lean_object* x_857; lean_object* x_858; lean_object* x_859; lean_object* x_860; lean_object* x_861; 
-x_847 = lean_ctor_get(x_1, 1);
-x_848 = lean_ctor_get(x_1, 2);
-lean_inc(x_848);
+lean_object* x_780; 
+lean_free_object(x_242);
+x_780 = lean_ctor_get(x_4, 3);
+lean_inc(x_780);
+if (lean_obj_tag(x_780) == 0)
+{
+uint8_t x_781; 
+x_781 = !lean_is_exclusive(x_621);
+if (x_781 == 0)
+{
+lean_object* x_782; lean_object* x_783; lean_object* x_784; lean_object* x_785; uint8_t x_786; 
+x_782 = lean_ctor_get(x_621, 3);
+lean_dec(x_782);
+x_783 = lean_ctor_get(x_621, 2);
+lean_dec(x_783);
+x_784 = lean_ctor_get(x_621, 1);
+lean_dec(x_784);
+x_785 = lean_ctor_get(x_621, 0);
+lean_dec(x_785);
+x_786 = 1;
+lean_ctor_set(x_621, 3, x_4);
+lean_ctor_set(x_621, 2, x_3);
+lean_ctor_set(x_621, 1, x_2);
+lean_ctor_set(x_621, 0, x_1);
+lean_ctor_set_uint8(x_621, sizeof(void*)*4, x_786);
+return x_621;
+}
+else
+{
+uint8_t x_787; lean_object* x_788; 
+lean_dec(x_621);
+x_787 = 1;
+x_788 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_788, 0, x_1);
+lean_ctor_set(x_788, 1, x_2);
+lean_ctor_set(x_788, 2, x_3);
+lean_ctor_set(x_788, 3, x_4);
+lean_ctor_set_uint8(x_788, sizeof(void*)*4, x_787);
+return x_788;
+}
+}
+else
+{
+uint8_t x_789; 
+x_789 = lean_ctor_get_uint8(x_780, sizeof(void*)*4);
+if (x_789 == 0)
+{
+uint8_t x_790; 
+x_790 = !lean_is_exclusive(x_4);
+if (x_790 == 0)
+{
+lean_object* x_791; lean_object* x_792; uint8_t x_793; 
+x_791 = lean_ctor_get(x_4, 3);
+lean_dec(x_791);
+x_792 = lean_ctor_get(x_4, 0);
+lean_dec(x_792);
+x_793 = !lean_is_exclusive(x_780);
+if (x_793 == 0)
+{
+lean_object* x_794; lean_object* x_795; lean_object* x_796; lean_object* x_797; uint8_t x_798; uint8_t x_799; 
+x_794 = lean_ctor_get(x_780, 0);
+x_795 = lean_ctor_get(x_780, 1);
+x_796 = lean_ctor_get(x_780, 2);
+x_797 = lean_ctor_get(x_780, 3);
+x_798 = 1;
+lean_inc(x_621);
+lean_ctor_set(x_780, 3, x_621);
+lean_ctor_set(x_780, 2, x_3);
+lean_ctor_set(x_780, 1, x_2);
+lean_ctor_set(x_780, 0, x_1);
+x_799 = !lean_is_exclusive(x_621);
+if (x_799 == 0)
+{
+lean_object* x_800; lean_object* x_801; lean_object* x_802; lean_object* x_803; uint8_t x_804; 
+x_800 = lean_ctor_get(x_621, 3);
+lean_dec(x_800);
+x_801 = lean_ctor_get(x_621, 2);
+lean_dec(x_801);
+x_802 = lean_ctor_get(x_621, 1);
+lean_dec(x_802);
+x_803 = lean_ctor_get(x_621, 0);
+lean_dec(x_803);
+lean_ctor_set_uint8(x_780, sizeof(void*)*4, x_798);
+lean_ctor_set(x_621, 3, x_797);
+lean_ctor_set(x_621, 2, x_796);
+lean_ctor_set(x_621, 1, x_795);
+lean_ctor_set(x_621, 0, x_794);
+lean_ctor_set_uint8(x_621, sizeof(void*)*4, x_798);
+x_804 = 0;
+lean_ctor_set(x_4, 3, x_621);
+lean_ctor_set(x_4, 0, x_780);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_804);
+return x_4;
+}
+else
+{
+lean_object* x_805; uint8_t x_806; 
+lean_dec(x_621);
+lean_ctor_set_uint8(x_780, sizeof(void*)*4, x_798);
+x_805 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_805, 0, x_794);
+lean_ctor_set(x_805, 1, x_795);
+lean_ctor_set(x_805, 2, x_796);
+lean_ctor_set(x_805, 3, x_797);
+lean_ctor_set_uint8(x_805, sizeof(void*)*4, x_798);
+x_806 = 0;
+lean_ctor_set(x_4, 3, x_805);
+lean_ctor_set(x_4, 0, x_780);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_806);
+return x_4;
+}
+}
+else
+{
+lean_object* x_807; lean_object* x_808; lean_object* x_809; lean_object* x_810; uint8_t x_811; lean_object* x_812; lean_object* x_813; lean_object* x_814; uint8_t x_815; 
+x_807 = lean_ctor_get(x_780, 0);
+x_808 = lean_ctor_get(x_780, 1);
+x_809 = lean_ctor_get(x_780, 2);
+x_810 = lean_ctor_get(x_780, 3);
+lean_inc(x_810);
+lean_inc(x_809);
+lean_inc(x_808);
+lean_inc(x_807);
+lean_dec(x_780);
+x_811 = 1;
+lean_inc(x_621);
+x_812 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_812, 0, x_1);
+lean_ctor_set(x_812, 1, x_2);
+lean_ctor_set(x_812, 2, x_3);
+lean_ctor_set(x_812, 3, x_621);
+if (lean_is_exclusive(x_621)) {
+ lean_ctor_release(x_621, 0);
+ lean_ctor_release(x_621, 1);
+ lean_ctor_release(x_621, 2);
+ lean_ctor_release(x_621, 3);
+ x_813 = x_621;
+} else {
+ lean_dec_ref(x_621);
+ x_813 = lean_box(0);
+}
+lean_ctor_set_uint8(x_812, sizeof(void*)*4, x_811);
+if (lean_is_scalar(x_813)) {
+ x_814 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_814 = x_813;
+}
+lean_ctor_set(x_814, 0, x_807);
+lean_ctor_set(x_814, 1, x_808);
+lean_ctor_set(x_814, 2, x_809);
+lean_ctor_set(x_814, 3, x_810);
+lean_ctor_set_uint8(x_814, sizeof(void*)*4, x_811);
+x_815 = 0;
+lean_ctor_set(x_4, 3, x_814);
+lean_ctor_set(x_4, 0, x_812);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_815);
+return x_4;
+}
+}
+else
+{
+lean_object* x_816; lean_object* x_817; lean_object* x_818; lean_object* x_819; lean_object* x_820; lean_object* x_821; lean_object* x_822; uint8_t x_823; lean_object* x_824; lean_object* x_825; lean_object* x_826; uint8_t x_827; lean_object* x_828; 
+x_816 = lean_ctor_get(x_4, 1);
+x_817 = lean_ctor_get(x_4, 2);
+lean_inc(x_817);
+lean_inc(x_816);
+lean_dec(x_4);
+x_818 = lean_ctor_get(x_780, 0);
+lean_inc(x_818);
+x_819 = lean_ctor_get(x_780, 1);
+lean_inc(x_819);
+x_820 = lean_ctor_get(x_780, 2);
+lean_inc(x_820);
+x_821 = lean_ctor_get(x_780, 3);
+lean_inc(x_821);
+if (lean_is_exclusive(x_780)) {
+ lean_ctor_release(x_780, 0);
+ lean_ctor_release(x_780, 1);
+ lean_ctor_release(x_780, 2);
+ lean_ctor_release(x_780, 3);
+ x_822 = x_780;
+} else {
+ lean_dec_ref(x_780);
+ x_822 = lean_box(0);
+}
+x_823 = 1;
+lean_inc(x_621);
+if (lean_is_scalar(x_822)) {
+ x_824 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_824 = x_822;
+}
+lean_ctor_set(x_824, 0, x_1);
+lean_ctor_set(x_824, 1, x_2);
+lean_ctor_set(x_824, 2, x_3);
+lean_ctor_set(x_824, 3, x_621);
+if (lean_is_exclusive(x_621)) {
+ lean_ctor_release(x_621, 0);
+ lean_ctor_release(x_621, 1);
+ lean_ctor_release(x_621, 2);
+ lean_ctor_release(x_621, 3);
+ x_825 = x_621;
+} else {
+ lean_dec_ref(x_621);
+ x_825 = lean_box(0);
+}
+lean_ctor_set_uint8(x_824, sizeof(void*)*4, x_823);
+if (lean_is_scalar(x_825)) {
+ x_826 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_826 = x_825;
+}
+lean_ctor_set(x_826, 0, x_818);
+lean_ctor_set(x_826, 1, x_819);
+lean_ctor_set(x_826, 2, x_820);
+lean_ctor_set(x_826, 3, x_821);
+lean_ctor_set_uint8(x_826, sizeof(void*)*4, x_823);
+x_827 = 0;
+x_828 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_828, 0, x_824);
+lean_ctor_set(x_828, 1, x_816);
+lean_ctor_set(x_828, 2, x_817);
+lean_ctor_set(x_828, 3, x_826);
+lean_ctor_set_uint8(x_828, sizeof(void*)*4, x_827);
+return x_828;
+}
+}
+else
+{
+uint8_t x_829; 
+lean_dec(x_621);
+x_829 = !lean_is_exclusive(x_780);
+if (x_829 == 0)
+{
+lean_object* x_830; lean_object* x_831; lean_object* x_832; lean_object* x_833; uint8_t x_834; 
+x_830 = lean_ctor_get(x_780, 3);
+lean_dec(x_830);
+x_831 = lean_ctor_get(x_780, 2);
+lean_dec(x_831);
+x_832 = lean_ctor_get(x_780, 1);
+lean_dec(x_832);
+x_833 = lean_ctor_get(x_780, 0);
+lean_dec(x_833);
+x_834 = 1;
+lean_ctor_set(x_780, 3, x_4);
+lean_ctor_set(x_780, 2, x_3);
+lean_ctor_set(x_780, 1, x_2);
+lean_ctor_set(x_780, 0, x_1);
+lean_ctor_set_uint8(x_780, sizeof(void*)*4, x_834);
+return x_780;
+}
+else
+{
+uint8_t x_835; lean_object* x_836; 
+lean_dec(x_780);
+x_835 = 1;
+x_836 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_836, 0, x_1);
+lean_ctor_set(x_836, 1, x_2);
+lean_ctor_set(x_836, 2, x_3);
+lean_ctor_set(x_836, 3, x_4);
+lean_ctor_set_uint8(x_836, sizeof(void*)*4, x_835);
+return x_836;
+}
+}
+}
+}
+}
+}
+else
+{
+uint8_t x_837; 
+x_837 = 1;
+lean_ctor_set(x_242, 3, x_4);
+lean_ctor_set(x_242, 2, x_3);
+lean_ctor_set(x_242, 1, x_2);
+lean_ctor_set(x_242, 0, x_1);
+lean_ctor_set_uint8(x_242, sizeof(void*)*4, x_837);
+return x_242;
+}
+}
+}
+else
+{
+lean_dec(x_242);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_838; lean_object* x_839; 
+x_838 = 1;
+x_839 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_839, 0, x_1);
+lean_ctor_set(x_839, 1, x_2);
+lean_ctor_set(x_839, 2, x_3);
+lean_ctor_set(x_839, 3, x_4);
+lean_ctor_set_uint8(x_839, sizeof(void*)*4, x_838);
+return x_839;
+}
+else
+{
+uint8_t x_840; 
+x_840 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_840 == 0)
+{
+lean_object* x_841; 
+x_841 = lean_ctor_get(x_4, 0);
+lean_inc(x_841);
+if (lean_obj_tag(x_841) == 0)
+{
+lean_object* x_842; 
+x_842 = lean_ctor_get(x_4, 3);
+lean_inc(x_842);
+if (lean_obj_tag(x_842) == 0)
+{
+uint8_t x_843; lean_object* x_844; 
+x_843 = 1;
+x_844 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_844, 0, x_1);
+lean_ctor_set(x_844, 1, x_2);
+lean_ctor_set(x_844, 2, x_3);
+lean_ctor_set(x_844, 3, x_4);
+lean_ctor_set_uint8(x_844, sizeof(void*)*4, x_843);
+return x_844;
+}
+else
+{
+uint8_t x_845; 
+x_845 = lean_ctor_get_uint8(x_842, sizeof(void*)*4);
+if (x_845 == 0)
+{
+lean_object* x_846; lean_object* x_847; lean_object* x_848; lean_object* x_849; lean_object* x_850; lean_object* x_851; lean_object* x_852; lean_object* x_853; uint8_t x_854; lean_object* x_855; lean_object* x_856; uint8_t x_857; lean_object* x_858; 
+x_846 = lean_ctor_get(x_4, 1);
+lean_inc(x_846);
+x_847 = lean_ctor_get(x_4, 2);
 lean_inc(x_847);
-lean_dec(x_1);
-x_849 = lean_ctor_get(x_4, 1);
-lean_inc(x_849);
-x_850 = lean_ctor_get(x_4, 2);
-lean_inc(x_850);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
- x_851 = x_4;
+ x_848 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_851 = lean_box(0);
+ x_848 = lean_box(0);
 }
-x_852 = lean_ctor_get(x_679, 0);
+x_849 = lean_ctor_get(x_842, 0);
+lean_inc(x_849);
+x_850 = lean_ctor_get(x_842, 1);
+lean_inc(x_850);
+x_851 = lean_ctor_get(x_842, 2);
+lean_inc(x_851);
+x_852 = lean_ctor_get(x_842, 3);
 lean_inc(x_852);
-x_853 = lean_ctor_get(x_679, 1);
-lean_inc(x_853);
-x_854 = lean_ctor_get(x_679, 2);
-lean_inc(x_854);
-x_855 = lean_ctor_get(x_679, 3);
-lean_inc(x_855);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_856 = x_679;
+if (lean_is_exclusive(x_842)) {
+ lean_ctor_release(x_842, 0);
+ lean_ctor_release(x_842, 1);
+ lean_ctor_release(x_842, 2);
+ lean_ctor_release(x_842, 3);
+ x_853 = x_842;
 } else {
- lean_dec_ref(x_679);
- x_856 = lean_box(0);
+ lean_dec_ref(x_842);
+ x_853 = lean_box(0);
 }
-lean_inc(x_235);
-if (lean_is_scalar(x_856)) {
- x_857 = lean_alloc_ctor(1, 4, 1);
+x_854 = 1;
+if (lean_is_scalar(x_853)) {
+ x_855 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_857 = x_856;
+ x_855 = x_853;
 }
-lean_ctor_set(x_857, 0, x_807);
-lean_ctor_set(x_857, 1, x_847);
-lean_ctor_set(x_857, 2, x_848);
-lean_ctor_set(x_857, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_858 = x_235;
+lean_ctor_set(x_855, 0, x_1);
+lean_ctor_set(x_855, 1, x_2);
+lean_ctor_set(x_855, 2, x_3);
+lean_ctor_set(x_855, 3, x_841);
+lean_ctor_set_uint8(x_855, sizeof(void*)*4, x_854);
+if (lean_is_scalar(x_848)) {
+ x_856 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_235);
- x_858 = lean_box(0);
+ x_856 = x_848;
 }
-lean_ctor_set_uint8(x_857, sizeof(void*)*4, x_806);
-if (lean_is_scalar(x_851)) {
- x_859 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_856, 0, x_849);
+lean_ctor_set(x_856, 1, x_850);
+lean_ctor_set(x_856, 2, x_851);
+lean_ctor_set(x_856, 3, x_852);
+lean_ctor_set_uint8(x_856, sizeof(void*)*4, x_854);
+x_857 = 0;
+x_858 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_858, 0, x_855);
+lean_ctor_set(x_858, 1, x_846);
+lean_ctor_set(x_858, 2, x_847);
+lean_ctor_set(x_858, 3, x_856);
+lean_ctor_set_uint8(x_858, sizeof(void*)*4, x_857);
+return x_858;
+}
+else
+{
+lean_object* x_859; uint8_t x_860; lean_object* x_861; 
+if (lean_is_exclusive(x_842)) {
+ lean_ctor_release(x_842, 0);
+ lean_ctor_release(x_842, 1);
+ lean_ctor_release(x_842, 2);
+ lean_ctor_release(x_842, 3);
+ x_859 = x_842;
 } else {
- x_859 = x_851;
+ lean_dec_ref(x_842);
+ x_859 = lean_box(0);
 }
-lean_ctor_set(x_859, 0, x_857);
-lean_ctor_set(x_859, 1, x_2);
-lean_ctor_set(x_859, 2, x_3);
-lean_ctor_set(x_859, 3, x_852);
-lean_ctor_set_uint8(x_859, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_858)) {
- x_860 = lean_alloc_ctor(1, 4, 1);
+x_860 = 1;
+if (lean_is_scalar(x_859)) {
+ x_861 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_860 = x_858;
+ x_861 = x_859;
 }
-lean_ctor_set(x_860, 0, x_855);
-lean_ctor_set(x_860, 1, x_849);
-lean_ctor_set(x_860, 2, x_850);
-lean_ctor_set(x_860, 3, x_807);
-lean_ctor_set_uint8(x_860, sizeof(void*)*4, x_639);
-x_861 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_861, 0, x_859);
-lean_ctor_set(x_861, 1, x_853);
-lean_ctor_set(x_861, 2, x_854);
-lean_ctor_set(x_861, 3, x_860);
-lean_ctor_set_uint8(x_861, sizeof(void*)*4, x_806);
+lean_ctor_set(x_861, 0, x_1);
+lean_ctor_set(x_861, 1, x_2);
+lean_ctor_set(x_861, 2, x_3);
+lean_ctor_set(x_861, 3, x_4);
+lean_ctor_set_uint8(x_861, sizeof(void*)*4, x_860);
 return x_861;
 }
 }
+}
 else
 {
 uint8_t x_862; 
-x_862 = lean_ctor_get_uint8(x_807, sizeof(void*)*4);
+x_862 = lean_ctor_get_uint8(x_841, sizeof(void*)*4);
 if (x_862 == 0)
 {
-uint8_t x_863; 
-x_863 = !lean_is_exclusive(x_1);
-if (x_863 == 0)
+lean_object* x_863; 
+x_863 = lean_ctor_get(x_4, 3);
+lean_inc(x_863);
+if (lean_obj_tag(x_863) == 0)
 {
-lean_object* x_864; lean_object* x_865; lean_object* x_866; lean_object* x_867; uint8_t x_868; 
-x_864 = lean_ctor_get(x_1, 1);
-x_865 = lean_ctor_get(x_1, 2);
-x_866 = lean_ctor_get(x_1, 3);
-lean_dec(x_866);
-x_867 = lean_ctor_get(x_1, 0);
-lean_dec(x_867);
-x_868 = !lean_is_exclusive(x_4);
-if (x_868 == 0)
-{
-lean_object* x_869; lean_object* x_870; lean_object* x_871; lean_object* x_872; uint8_t x_873; 
-x_869 = lean_ctor_get(x_4, 1);
-x_870 = lean_ctor_get(x_4, 2);
-x_871 = lean_ctor_get(x_4, 3);
-lean_dec(x_871);
-x_872 = lean_ctor_get(x_4, 0);
-lean_dec(x_872);
-x_873 = !lean_is_exclusive(x_679);
-if (x_873 == 0)
-{
-uint8_t x_874; 
-x_874 = !lean_is_exclusive(x_807);
-if (x_874 == 0)
-{
-lean_object* x_875; lean_object* x_876; lean_object* x_877; lean_object* x_878; uint8_t x_879; 
-x_875 = lean_ctor_get(x_807, 0);
-x_876 = lean_ctor_get(x_807, 1);
-x_877 = lean_ctor_get(x_807, 2);
-x_878 = lean_ctor_get(x_807, 3);
-lean_inc(x_235);
-lean_ctor_set(x_807, 3, x_235);
-lean_ctor_set(x_807, 2, x_865);
-lean_ctor_set(x_807, 1, x_864);
-lean_ctor_set(x_807, 0, x_234);
-x_879 = !lean_is_exclusive(x_235);
-if (x_879 == 0)
-{
-lean_object* x_880; lean_object* x_881; lean_object* x_882; lean_object* x_883; 
-x_880 = lean_ctor_get(x_235, 3);
-lean_dec(x_880);
-x_881 = lean_ctor_get(x_235, 2);
-lean_dec(x_881);
-x_882 = lean_ctor_get(x_235, 1);
-lean_dec(x_882);
-x_883 = lean_ctor_get(x_235, 0);
-lean_dec(x_883);
-lean_ctor_set_uint8(x_679, sizeof(void*)*4, x_862);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_807);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-lean_ctor_set(x_235, 3, x_878);
-lean_ctor_set(x_235, 2, x_877);
-lean_ctor_set(x_235, 1, x_876);
-lean_ctor_set(x_235, 0, x_875);
-lean_ctor_set(x_1, 2, x_870);
-lean_ctor_set(x_1, 1, x_869);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-return x_1;
-}
-else
-{
-lean_object* x_884; 
-lean_dec(x_235);
-lean_ctor_set_uint8(x_679, sizeof(void*)*4, x_862);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_807);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-x_884 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_884, 0, x_875);
-lean_ctor_set(x_884, 1, x_876);
-lean_ctor_set(x_884, 2, x_877);
-lean_ctor_set(x_884, 3, x_878);
-lean_ctor_set_uint8(x_884, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_884);
-lean_ctor_set(x_1, 2, x_870);
-lean_ctor_set(x_1, 1, x_869);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-return x_1;
-}
-}
-else
-{
-lean_object* x_885; lean_object* x_886; lean_object* x_887; lean_object* x_888; lean_object* x_889; lean_object* x_890; lean_object* x_891; 
-x_885 = lean_ctor_get(x_807, 0);
-x_886 = lean_ctor_get(x_807, 1);
-x_887 = lean_ctor_get(x_807, 2);
-x_888 = lean_ctor_get(x_807, 3);
-lean_inc(x_888);
-lean_inc(x_887);
-lean_inc(x_886);
-lean_inc(x_885);
-lean_dec(x_807);
-lean_inc(x_235);
-x_889 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_889, 0, x_234);
-lean_ctor_set(x_889, 1, x_864);
-lean_ctor_set(x_889, 2, x_865);
-lean_ctor_set(x_889, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_890 = x_235;
+lean_object* x_864; lean_object* x_865; lean_object* x_866; lean_object* x_867; lean_object* x_868; lean_object* x_869; lean_object* x_870; lean_object* x_871; uint8_t x_872; lean_object* x_873; lean_object* x_874; uint8_t x_875; lean_object* x_876; 
+x_864 = lean_ctor_get(x_4, 1);
+lean_inc(x_864);
+x_865 = lean_ctor_get(x_4, 2);
+lean_inc(x_865);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_866 = x_4;
 } else {
- lean_dec_ref(x_235);
+ lean_dec_ref(x_4);
+ x_866 = lean_box(0);
+}
+x_867 = lean_ctor_get(x_841, 0);
+lean_inc(x_867);
+x_868 = lean_ctor_get(x_841, 1);
+lean_inc(x_868);
+x_869 = lean_ctor_get(x_841, 2);
+lean_inc(x_869);
+x_870 = lean_ctor_get(x_841, 3);
+lean_inc(x_870);
+if (lean_is_exclusive(x_841)) {
+ lean_ctor_release(x_841, 0);
+ lean_ctor_release(x_841, 1);
+ lean_ctor_release(x_841, 2);
+ lean_ctor_release(x_841, 3);
+ x_871 = x_841;
+} else {
+ lean_dec_ref(x_841);
+ x_871 = lean_box(0);
+}
+x_872 = 1;
+if (lean_is_scalar(x_871)) {
+ x_873 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_873 = x_871;
+}
+lean_ctor_set(x_873, 0, x_1);
+lean_ctor_set(x_873, 1, x_2);
+lean_ctor_set(x_873, 2, x_3);
+lean_ctor_set(x_873, 3, x_867);
+lean_ctor_set_uint8(x_873, sizeof(void*)*4, x_872);
+if (lean_is_scalar(x_866)) {
+ x_874 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_874 = x_866;
+}
+lean_ctor_set(x_874, 0, x_870);
+lean_ctor_set(x_874, 1, x_864);
+lean_ctor_set(x_874, 2, x_865);
+lean_ctor_set(x_874, 3, x_863);
+lean_ctor_set_uint8(x_874, sizeof(void*)*4, x_872);
+x_875 = 0;
+x_876 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_876, 0, x_873);
+lean_ctor_set(x_876, 1, x_868);
+lean_ctor_set(x_876, 2, x_869);
+lean_ctor_set(x_876, 3, x_874);
+lean_ctor_set_uint8(x_876, sizeof(void*)*4, x_875);
+return x_876;
+}
+else
+{
+uint8_t x_877; 
+x_877 = lean_ctor_get_uint8(x_863, sizeof(void*)*4);
+if (x_877 == 0)
+{
+lean_object* x_878; lean_object* x_879; lean_object* x_880; lean_object* x_881; lean_object* x_882; lean_object* x_883; lean_object* x_884; lean_object* x_885; lean_object* x_886; lean_object* x_887; lean_object* x_888; lean_object* x_889; lean_object* x_890; lean_object* x_891; uint8_t x_892; lean_object* x_893; lean_object* x_894; uint8_t x_895; lean_object* x_896; 
+x_878 = lean_ctor_get(x_4, 1);
+lean_inc(x_878);
+x_879 = lean_ctor_get(x_4, 2);
+lean_inc(x_879);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_880 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_880 = lean_box(0);
+}
+x_881 = lean_ctor_get(x_841, 0);
+lean_inc(x_881);
+x_882 = lean_ctor_get(x_841, 1);
+lean_inc(x_882);
+x_883 = lean_ctor_get(x_841, 2);
+lean_inc(x_883);
+x_884 = lean_ctor_get(x_841, 3);
+lean_inc(x_884);
+if (lean_is_exclusive(x_841)) {
+ lean_ctor_release(x_841, 0);
+ lean_ctor_release(x_841, 1);
+ lean_ctor_release(x_841, 2);
+ lean_ctor_release(x_841, 3);
+ x_885 = x_841;
+} else {
+ lean_dec_ref(x_841);
+ x_885 = lean_box(0);
+}
+x_886 = lean_ctor_get(x_863, 0);
+lean_inc(x_886);
+x_887 = lean_ctor_get(x_863, 1);
+lean_inc(x_887);
+x_888 = lean_ctor_get(x_863, 2);
+lean_inc(x_888);
+x_889 = lean_ctor_get(x_863, 3);
+lean_inc(x_889);
+if (lean_is_exclusive(x_863)) {
+ lean_ctor_release(x_863, 0);
+ lean_ctor_release(x_863, 1);
+ lean_ctor_release(x_863, 2);
+ lean_ctor_release(x_863, 3);
+ x_890 = x_863;
+} else {
+ lean_dec_ref(x_863);
  x_890 = lean_box(0);
 }
-lean_ctor_set_uint8(x_889, sizeof(void*)*4, x_862);
-lean_ctor_set_uint8(x_679, sizeof(void*)*4, x_862);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_889);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
 if (lean_is_scalar(x_890)) {
  x_891 = lean_alloc_ctor(1, 4, 1);
 } else {
  x_891 = x_890;
 }
-lean_ctor_set(x_891, 0, x_885);
-lean_ctor_set(x_891, 1, x_886);
-lean_ctor_set(x_891, 2, x_887);
-lean_ctor_set(x_891, 3, x_888);
-lean_ctor_set_uint8(x_891, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_891);
-lean_ctor_set(x_1, 2, x_870);
-lean_ctor_set(x_1, 1, x_869);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-return x_1;
+lean_ctor_set(x_891, 0, x_881);
+lean_ctor_set(x_891, 1, x_882);
+lean_ctor_set(x_891, 2, x_883);
+lean_ctor_set(x_891, 3, x_884);
+lean_ctor_set_uint8(x_891, sizeof(void*)*4, x_877);
+x_892 = 1;
+if (lean_is_scalar(x_885)) {
+ x_893 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_893 = x_885;
 }
+lean_ctor_set(x_893, 0, x_1);
+lean_ctor_set(x_893, 1, x_2);
+lean_ctor_set(x_893, 2, x_3);
+lean_ctor_set(x_893, 3, x_891);
+lean_ctor_set_uint8(x_893, sizeof(void*)*4, x_892);
+if (lean_is_scalar(x_880)) {
+ x_894 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_894 = x_880;
+}
+lean_ctor_set(x_894, 0, x_886);
+lean_ctor_set(x_894, 1, x_887);
+lean_ctor_set(x_894, 2, x_888);
+lean_ctor_set(x_894, 3, x_889);
+lean_ctor_set_uint8(x_894, sizeof(void*)*4, x_892);
+x_895 = 0;
+x_896 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_896, 0, x_893);
+lean_ctor_set(x_896, 1, x_878);
+lean_ctor_set(x_896, 2, x_879);
+lean_ctor_set(x_896, 3, x_894);
+lean_ctor_set_uint8(x_896, sizeof(void*)*4, x_895);
+return x_896;
 }
 else
 {
-lean_object* x_892; lean_object* x_893; lean_object* x_894; lean_object* x_895; lean_object* x_896; lean_object* x_897; lean_object* x_898; lean_object* x_899; lean_object* x_900; lean_object* x_901; lean_object* x_902; lean_object* x_903; lean_object* x_904; 
-x_892 = lean_ctor_get(x_679, 0);
-x_893 = lean_ctor_get(x_679, 1);
-x_894 = lean_ctor_get(x_679, 2);
-x_895 = lean_ctor_get(x_679, 3);
-lean_inc(x_895);
-lean_inc(x_894);
-lean_inc(x_893);
-lean_inc(x_892);
-lean_dec(x_679);
-x_896 = lean_ctor_get(x_807, 0);
-lean_inc(x_896);
-x_897 = lean_ctor_get(x_807, 1);
+lean_object* x_897; lean_object* x_898; lean_object* x_899; lean_object* x_900; lean_object* x_901; lean_object* x_902; lean_object* x_903; lean_object* x_904; uint8_t x_905; lean_object* x_906; lean_object* x_907; uint8_t x_908; lean_object* x_909; 
+x_897 = lean_ctor_get(x_4, 1);
 lean_inc(x_897);
-x_898 = lean_ctor_get(x_807, 2);
+x_898 = lean_ctor_get(x_4, 2);
 lean_inc(x_898);
-x_899 = lean_ctor_get(x_807, 3);
-lean_inc(x_899);
-if (lean_is_exclusive(x_807)) {
- lean_ctor_release(x_807, 0);
- lean_ctor_release(x_807, 1);
- lean_ctor_release(x_807, 2);
- lean_ctor_release(x_807, 3);
- x_900 = x_807;
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_899 = x_4;
 } else {
- lean_dec_ref(x_807);
- x_900 = lean_box(0);
+ lean_dec_ref(x_4);
+ x_899 = lean_box(0);
 }
-lean_inc(x_235);
-if (lean_is_scalar(x_900)) {
- x_901 = lean_alloc_ctor(1, 4, 1);
+x_900 = lean_ctor_get(x_841, 0);
+lean_inc(x_900);
+x_901 = lean_ctor_get(x_841, 1);
+lean_inc(x_901);
+x_902 = lean_ctor_get(x_841, 2);
+lean_inc(x_902);
+x_903 = lean_ctor_get(x_841, 3);
+lean_inc(x_903);
+if (lean_is_exclusive(x_841)) {
+ lean_ctor_release(x_841, 0);
+ lean_ctor_release(x_841, 1);
+ lean_ctor_release(x_841, 2);
+ lean_ctor_release(x_841, 3);
+ x_904 = x_841;
 } else {
- x_901 = x_900;
+ lean_dec_ref(x_841);
+ x_904 = lean_box(0);
 }
-lean_ctor_set(x_901, 0, x_234);
-lean_ctor_set(x_901, 1, x_864);
-lean_ctor_set(x_901, 2, x_865);
-lean_ctor_set(x_901, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_902 = x_235;
+x_905 = 1;
+if (lean_is_scalar(x_904)) {
+ x_906 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_235);
- x_902 = lean_box(0);
+ x_906 = x_904;
 }
-lean_ctor_set_uint8(x_901, sizeof(void*)*4, x_862);
-x_903 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_903, 0, x_892);
-lean_ctor_set(x_903, 1, x_893);
-lean_ctor_set(x_903, 2, x_894);
-lean_ctor_set(x_903, 3, x_895);
-lean_ctor_set_uint8(x_903, sizeof(void*)*4, x_862);
-lean_ctor_set(x_4, 3, x_903);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_901);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_902)) {
- x_904 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_906, 0, x_1);
+lean_ctor_set(x_906, 1, x_2);
+lean_ctor_set(x_906, 2, x_3);
+lean_ctor_set(x_906, 3, x_900);
+lean_ctor_set_uint8(x_906, sizeof(void*)*4, x_905);
+if (lean_is_scalar(x_899)) {
+ x_907 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_904 = x_902;
+ x_907 = x_899;
+}
+lean_ctor_set(x_907, 0, x_903);
+lean_ctor_set(x_907, 1, x_897);
+lean_ctor_set(x_907, 2, x_898);
+lean_ctor_set(x_907, 3, x_863);
+lean_ctor_set_uint8(x_907, sizeof(void*)*4, x_905);
+x_908 = 0;
+x_909 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_909, 0, x_906);
+lean_ctor_set(x_909, 1, x_901);
+lean_ctor_set(x_909, 2, x_902);
+lean_ctor_set(x_909, 3, x_907);
+lean_ctor_set_uint8(x_909, sizeof(void*)*4, x_908);
+return x_909;
 }
-lean_ctor_set(x_904, 0, x_896);
-lean_ctor_set(x_904, 1, x_897);
-lean_ctor_set(x_904, 2, x_898);
-lean_ctor_set(x_904, 3, x_899);
-lean_ctor_set_uint8(x_904, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_904);
-lean_ctor_set(x_1, 2, x_870);
-lean_ctor_set(x_1, 1, x_869);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-return x_1;
 }
 }
 else
 {
-lean_object* x_905; lean_object* x_906; lean_object* x_907; lean_object* x_908; lean_object* x_909; lean_object* x_910; lean_object* x_911; lean_object* x_912; lean_object* x_913; lean_object* x_914; lean_object* x_915; lean_object* x_916; lean_object* x_917; lean_object* x_918; lean_object* x_919; lean_object* x_920; lean_object* x_921; 
-x_905 = lean_ctor_get(x_4, 1);
-x_906 = lean_ctor_get(x_4, 2);
-lean_inc(x_906);
-lean_inc(x_905);
-lean_dec(x_4);
-x_907 = lean_ctor_get(x_679, 0);
-lean_inc(x_907);
-x_908 = lean_ctor_get(x_679, 1);
-lean_inc(x_908);
-x_909 = lean_ctor_get(x_679, 2);
-lean_inc(x_909);
-x_910 = lean_ctor_get(x_679, 3);
+lean_object* x_910; 
+x_910 = lean_ctor_get(x_4, 3);
 lean_inc(x_910);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_911 = x_679;
+if (lean_obj_tag(x_910) == 0)
+{
+lean_object* x_911; uint8_t x_912; lean_object* x_913; 
+if (lean_is_exclusive(x_841)) {
+ lean_ctor_release(x_841, 0);
+ lean_ctor_release(x_841, 1);
+ lean_ctor_release(x_841, 2);
+ lean_ctor_release(x_841, 3);
+ x_911 = x_841;
 } else {
- lean_dec_ref(x_679);
+ lean_dec_ref(x_841);
  x_911 = lean_box(0);
 }
-x_912 = lean_ctor_get(x_807, 0);
-lean_inc(x_912);
-x_913 = lean_ctor_get(x_807, 1);
-lean_inc(x_913);
-x_914 = lean_ctor_get(x_807, 2);
-lean_inc(x_914);
-x_915 = lean_ctor_get(x_807, 3);
-lean_inc(x_915);
-if (lean_is_exclusive(x_807)) {
- lean_ctor_release(x_807, 0);
- lean_ctor_release(x_807, 1);
- lean_ctor_release(x_807, 2);
- lean_ctor_release(x_807, 3);
- x_916 = x_807;
-} else {
- lean_dec_ref(x_807);
- x_916 = lean_box(0);
-}
-lean_inc(x_235);
-if (lean_is_scalar(x_916)) {
- x_917 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_917 = x_916;
-}
-lean_ctor_set(x_917, 0, x_234);
-lean_ctor_set(x_917, 1, x_864);
-lean_ctor_set(x_917, 2, x_865);
-lean_ctor_set(x_917, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_918 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_918 = lean_box(0);
-}
-lean_ctor_set_uint8(x_917, sizeof(void*)*4, x_862);
+x_912 = 1;
 if (lean_is_scalar(x_911)) {
- x_919 = lean_alloc_ctor(1, 4, 1);
+ x_913 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_919 = x_911;
-}
-lean_ctor_set(x_919, 0, x_907);
-lean_ctor_set(x_919, 1, x_908);
-lean_ctor_set(x_919, 2, x_909);
-lean_ctor_set(x_919, 3, x_910);
-lean_ctor_set_uint8(x_919, sizeof(void*)*4, x_862);
-x_920 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_920, 0, x_917);
-lean_ctor_set(x_920, 1, x_2);
-lean_ctor_set(x_920, 2, x_3);
-lean_ctor_set(x_920, 3, x_919);
-lean_ctor_set_uint8(x_920, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_918)) {
- x_921 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_921 = x_918;
-}
-lean_ctor_set(x_921, 0, x_912);
-lean_ctor_set(x_921, 1, x_913);
-lean_ctor_set(x_921, 2, x_914);
-lean_ctor_set(x_921, 3, x_915);
-lean_ctor_set_uint8(x_921, sizeof(void*)*4, x_639);
-lean_ctor_set(x_1, 3, x_921);
-lean_ctor_set(x_1, 2, x_906);
-lean_ctor_set(x_1, 1, x_905);
-lean_ctor_set(x_1, 0, x_920);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-return x_1;
+ x_913 = x_911;
 }
+lean_ctor_set(x_913, 0, x_1);
+lean_ctor_set(x_913, 1, x_2);
+lean_ctor_set(x_913, 2, x_3);
+lean_ctor_set(x_913, 3, x_4);
+lean_ctor_set_uint8(x_913, sizeof(void*)*4, x_912);
+return x_913;
 }
 else
 {
-lean_object* x_922; lean_object* x_923; lean_object* x_924; lean_object* x_925; lean_object* x_926; lean_object* x_927; lean_object* x_928; lean_object* x_929; lean_object* x_930; lean_object* x_931; lean_object* x_932; lean_object* x_933; lean_object* x_934; lean_object* x_935; lean_object* x_936; lean_object* x_937; lean_object* x_938; lean_object* x_939; lean_object* x_940; lean_object* x_941; lean_object* x_942; 
-x_922 = lean_ctor_get(x_1, 1);
-x_923 = lean_ctor_get(x_1, 2);
-lean_inc(x_923);
-lean_inc(x_922);
-lean_dec(x_1);
-x_924 = lean_ctor_get(x_4, 1);
-lean_inc(x_924);
-x_925 = lean_ctor_get(x_4, 2);
-lean_inc(x_925);
+uint8_t x_914; 
+x_914 = lean_ctor_get_uint8(x_910, sizeof(void*)*4);
+if (x_914 == 0)
+{
+lean_object* x_915; lean_object* x_916; lean_object* x_917; lean_object* x_918; lean_object* x_919; lean_object* x_920; lean_object* x_921; lean_object* x_922; uint8_t x_923; lean_object* x_924; lean_object* x_925; lean_object* x_926; uint8_t x_927; lean_object* x_928; 
+x_915 = lean_ctor_get(x_4, 1);
+lean_inc(x_915);
+x_916 = lean_ctor_get(x_4, 2);
+lean_inc(x_916);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
- x_926 = x_4;
+ x_917 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_926 = lean_box(0);
+ x_917 = lean_box(0);
 }
-x_927 = lean_ctor_get(x_679, 0);
-lean_inc(x_927);
-x_928 = lean_ctor_get(x_679, 1);
-lean_inc(x_928);
-x_929 = lean_ctor_get(x_679, 2);
-lean_inc(x_929);
-x_930 = lean_ctor_get(x_679, 3);
-lean_inc(x_930);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_931 = x_679;
+x_918 = lean_ctor_get(x_910, 0);
+lean_inc(x_918);
+x_919 = lean_ctor_get(x_910, 1);
+lean_inc(x_919);
+x_920 = lean_ctor_get(x_910, 2);
+lean_inc(x_920);
+x_921 = lean_ctor_get(x_910, 3);
+lean_inc(x_921);
+if (lean_is_exclusive(x_910)) {
+ lean_ctor_release(x_910, 0);
+ lean_ctor_release(x_910, 1);
+ lean_ctor_release(x_910, 2);
+ lean_ctor_release(x_910, 3);
+ x_922 = x_910;
 } else {
- lean_dec_ref(x_679);
- x_931 = lean_box(0);
+ lean_dec_ref(x_910);
+ x_922 = lean_box(0);
 }
-x_932 = lean_ctor_get(x_807, 0);
-lean_inc(x_932);
-x_933 = lean_ctor_get(x_807, 1);
-lean_inc(x_933);
-x_934 = lean_ctor_get(x_807, 2);
-lean_inc(x_934);
-x_935 = lean_ctor_get(x_807, 3);
-lean_inc(x_935);
-if (lean_is_exclusive(x_807)) {
- lean_ctor_release(x_807, 0);
- lean_ctor_release(x_807, 1);
- lean_ctor_release(x_807, 2);
- lean_ctor_release(x_807, 3);
- x_936 = x_807;
+x_923 = 1;
+lean_inc(x_841);
+if (lean_is_scalar(x_922)) {
+ x_924 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_807);
- x_936 = lean_box(0);
+ x_924 = x_922;
 }
-lean_inc(x_235);
-if (lean_is_scalar(x_936)) {
- x_937 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_924, 0, x_1);
+lean_ctor_set(x_924, 1, x_2);
+lean_ctor_set(x_924, 2, x_3);
+lean_ctor_set(x_924, 3, x_841);
+if (lean_is_exclusive(x_841)) {
+ lean_ctor_release(x_841, 0);
+ lean_ctor_release(x_841, 1);
+ lean_ctor_release(x_841, 2);
+ lean_ctor_release(x_841, 3);
+ x_925 = x_841;
 } else {
- x_937 = x_936;
+ lean_dec_ref(x_841);
+ x_925 = lean_box(0);
 }
-lean_ctor_set(x_937, 0, x_234);
-lean_ctor_set(x_937, 1, x_922);
-lean_ctor_set(x_937, 2, x_923);
-lean_ctor_set(x_937, 3, x_235);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_938 = x_235;
+lean_ctor_set_uint8(x_924, sizeof(void*)*4, x_923);
+if (lean_is_scalar(x_925)) {
+ x_926 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_235);
- x_938 = lean_box(0);
+ x_926 = x_925;
 }
-lean_ctor_set_uint8(x_937, sizeof(void*)*4, x_862);
-if (lean_is_scalar(x_931)) {
- x_939 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_926, 0, x_918);
+lean_ctor_set(x_926, 1, x_919);
+lean_ctor_set(x_926, 2, x_920);
+lean_ctor_set(x_926, 3, x_921);
+lean_ctor_set_uint8(x_926, sizeof(void*)*4, x_923);
+x_927 = 0;
+if (lean_is_scalar(x_917)) {
+ x_928 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_939 = x_931;
+ x_928 = x_917;
 }
-lean_ctor_set(x_939, 0, x_927);
-lean_ctor_set(x_939, 1, x_928);
-lean_ctor_set(x_939, 2, x_929);
-lean_ctor_set(x_939, 3, x_930);
-lean_ctor_set_uint8(x_939, sizeof(void*)*4, x_862);
-if (lean_is_scalar(x_926)) {
- x_940 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_928, 0, x_924);
+lean_ctor_set(x_928, 1, x_915);
+lean_ctor_set(x_928, 2, x_916);
+lean_ctor_set(x_928, 3, x_926);
+lean_ctor_set_uint8(x_928, sizeof(void*)*4, x_927);
+return x_928;
+}
+else
+{
+lean_object* x_929; uint8_t x_930; lean_object* x_931; 
+lean_dec(x_841);
+if (lean_is_exclusive(x_910)) {
+ lean_ctor_release(x_910, 0);
+ lean_ctor_release(x_910, 1);
+ lean_ctor_release(x_910, 2);
+ lean_ctor_release(x_910, 3);
+ x_929 = x_910;
 } else {
- x_940 = x_926;
+ lean_dec_ref(x_910);
+ x_929 = lean_box(0);
 }
-lean_ctor_set(x_940, 0, x_937);
-lean_ctor_set(x_940, 1, x_2);
-lean_ctor_set(x_940, 2, x_3);
-lean_ctor_set(x_940, 3, x_939);
-lean_ctor_set_uint8(x_940, sizeof(void*)*4, x_639);
-if (lean_is_scalar(x_938)) {
- x_941 = lean_alloc_ctor(1, 4, 1);
+x_930 = 1;
+if (lean_is_scalar(x_929)) {
+ x_931 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_941 = x_938;
+ x_931 = x_929;
+}
+lean_ctor_set(x_931, 0, x_1);
+lean_ctor_set(x_931, 1, x_2);
+lean_ctor_set(x_931, 2, x_3);
+lean_ctor_set(x_931, 3, x_4);
+lean_ctor_set_uint8(x_931, sizeof(void*)*4, x_930);
+return x_931;
+}
+}
 }
-lean_ctor_set(x_941, 0, x_932);
-lean_ctor_set(x_941, 1, x_933);
-lean_ctor_set(x_941, 2, x_934);
-lean_ctor_set(x_941, 3, x_935);
-lean_ctor_set_uint8(x_941, sizeof(void*)*4, x_639);
-x_942 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_942, 0, x_940);
-lean_ctor_set(x_942, 1, x_924);
-lean_ctor_set(x_942, 2, x_925);
-lean_ctor_set(x_942, 3, x_941);
-lean_ctor_set_uint8(x_942, sizeof(void*)*4, x_862);
-return x_942;
 }
 }
 else
 {
-uint8_t x_943; 
-x_943 = !lean_is_exclusive(x_1);
-if (x_943 == 0)
-{
-lean_object* x_944; lean_object* x_945; lean_object* x_946; lean_object* x_947; uint8_t x_948; 
-x_944 = lean_ctor_get(x_1, 1);
-x_945 = lean_ctor_get(x_1, 2);
-x_946 = lean_ctor_get(x_1, 3);
-lean_dec(x_946);
-x_947 = lean_ctor_get(x_1, 0);
-lean_dec(x_947);
-x_948 = !lean_is_exclusive(x_235);
-if (x_948 == 0)
-{
-uint8_t x_949; 
-x_949 = !lean_is_exclusive(x_4);
-if (x_949 == 0)
-{
-lean_object* x_950; lean_object* x_951; lean_object* x_952; lean_object* x_953; lean_object* x_954; lean_object* x_955; lean_object* x_956; lean_object* x_957; uint8_t x_958; 
-x_950 = lean_ctor_get(x_235, 0);
-x_951 = lean_ctor_get(x_235, 1);
-x_952 = lean_ctor_get(x_235, 2);
-x_953 = lean_ctor_get(x_235, 3);
-x_954 = lean_ctor_get(x_4, 1);
-x_955 = lean_ctor_get(x_4, 2);
-x_956 = lean_ctor_get(x_4, 3);
-lean_dec(x_956);
-x_957 = lean_ctor_get(x_4, 0);
-lean_dec(x_957);
-x_958 = !lean_is_exclusive(x_679);
-if (x_958 == 0)
-{
-lean_object* x_959; lean_object* x_960; lean_object* x_961; lean_object* x_962; lean_object* x_963; 
-x_959 = lean_ctor_get(x_679, 0);
-x_960 = lean_ctor_get(x_679, 1);
-x_961 = lean_ctor_get(x_679, 2);
-x_962 = lean_ctor_get(x_679, 3);
-lean_ctor_set(x_679, 3, x_953);
-lean_ctor_set(x_679, 2, x_952);
-lean_ctor_set(x_679, 1, x_951);
-lean_ctor_set(x_679, 0, x_950);
-lean_ctor_set_uint8(x_679, sizeof(void*)*4, x_862);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_945);
-lean_ctor_set(x_4, 1, x_944);
-lean_ctor_set(x_4, 0, x_234);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_806);
-lean_ctor_set(x_235, 3, x_959);
-lean_ctor_set(x_235, 2, x_3);
-lean_ctor_set(x_235, 1, x_2);
-lean_ctor_set(x_235, 0, x_4);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_862);
-lean_ctor_set(x_1, 3, x_807);
-lean_ctor_set(x_1, 2, x_955);
-lean_ctor_set(x_1, 1, x_954);
-lean_ctor_set(x_1, 0, x_962);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-x_963 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_963, 0, x_235);
-lean_ctor_set(x_963, 1, x_960);
-lean_ctor_set(x_963, 2, x_961);
-lean_ctor_set(x_963, 3, x_1);
-lean_ctor_set_uint8(x_963, sizeof(void*)*4, x_806);
-return x_963;
+uint8_t x_932; lean_object* x_933; 
+x_932 = 1;
+x_933 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_933, 0, x_1);
+lean_ctor_set(x_933, 1, x_2);
+lean_ctor_set(x_933, 2, x_3);
+lean_ctor_set(x_933, 3, x_4);
+lean_ctor_set_uint8(x_933, sizeof(void*)*4, x_932);
+return x_933;
+}
+}
+}
+}
+}
 }
 else
 {
-lean_object* x_964; lean_object* x_965; lean_object* x_966; lean_object* x_967; lean_object* x_968; lean_object* x_969; 
-x_964 = lean_ctor_get(x_679, 0);
-x_965 = lean_ctor_get(x_679, 1);
-x_966 = lean_ctor_get(x_679, 2);
-x_967 = lean_ctor_get(x_679, 3);
-lean_inc(x_967);
-lean_inc(x_966);
+uint8_t x_934; 
+x_934 = lean_ctor_get_uint8(x_241, sizeof(void*)*4);
+if (x_934 == 0)
+{
+uint8_t x_935; 
+x_935 = !lean_is_exclusive(x_1);
+if (x_935 == 0)
+{
+lean_object* x_936; lean_object* x_937; lean_object* x_938; lean_object* x_939; uint8_t x_940; 
+x_936 = lean_ctor_get(x_1, 1);
+x_937 = lean_ctor_get(x_1, 2);
+x_938 = lean_ctor_get(x_1, 3);
+x_939 = lean_ctor_get(x_1, 0);
+lean_dec(x_939);
+x_940 = !lean_is_exclusive(x_241);
+if (x_940 == 0)
+{
+uint8_t x_941; uint8_t x_942; lean_object* x_943; 
+x_941 = 1;
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_941);
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set(x_1, 0, x_938);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_941);
+x_942 = 0;
+x_943 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_943, 0, x_241);
+lean_ctor_set(x_943, 1, x_936);
+lean_ctor_set(x_943, 2, x_937);
+lean_ctor_set(x_943, 3, x_1);
+lean_ctor_set_uint8(x_943, sizeof(void*)*4, x_942);
+return x_943;
+}
+else
+{
+lean_object* x_944; lean_object* x_945; lean_object* x_946; lean_object* x_947; uint8_t x_948; lean_object* x_949; uint8_t x_950; lean_object* x_951; 
+x_944 = lean_ctor_get(x_241, 0);
+x_945 = lean_ctor_get(x_241, 1);
+x_946 = lean_ctor_get(x_241, 2);
+x_947 = lean_ctor_get(x_241, 3);
+lean_inc(x_947);
+lean_inc(x_946);
+lean_inc(x_945);
+lean_inc(x_944);
+lean_dec(x_241);
+x_948 = 1;
+x_949 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_949, 0, x_944);
+lean_ctor_set(x_949, 1, x_945);
+lean_ctor_set(x_949, 2, x_946);
+lean_ctor_set(x_949, 3, x_947);
+lean_ctor_set_uint8(x_949, sizeof(void*)*4, x_948);
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set(x_1, 0, x_938);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_948);
+x_950 = 0;
+x_951 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_951, 0, x_949);
+lean_ctor_set(x_951, 1, x_936);
+lean_ctor_set(x_951, 2, x_937);
+lean_ctor_set(x_951, 3, x_1);
+lean_ctor_set_uint8(x_951, sizeof(void*)*4, x_950);
+return x_951;
+}
+}
+else
+{
+lean_object* x_952; lean_object* x_953; lean_object* x_954; lean_object* x_955; lean_object* x_956; lean_object* x_957; lean_object* x_958; lean_object* x_959; uint8_t x_960; lean_object* x_961; lean_object* x_962; uint8_t x_963; lean_object* x_964; 
+x_952 = lean_ctor_get(x_1, 1);
+x_953 = lean_ctor_get(x_1, 2);
+x_954 = lean_ctor_get(x_1, 3);
+lean_inc(x_954);
+lean_inc(x_953);
+lean_inc(x_952);
+lean_dec(x_1);
+x_955 = lean_ctor_get(x_241, 0);
+lean_inc(x_955);
+x_956 = lean_ctor_get(x_241, 1);
+lean_inc(x_956);
+x_957 = lean_ctor_get(x_241, 2);
+lean_inc(x_957);
+x_958 = lean_ctor_get(x_241, 3);
+lean_inc(x_958);
+if (lean_is_exclusive(x_241)) {
+ lean_ctor_release(x_241, 0);
+ lean_ctor_release(x_241, 1);
+ lean_ctor_release(x_241, 2);
+ lean_ctor_release(x_241, 3);
+ x_959 = x_241;
+} else {
+ lean_dec_ref(x_241);
+ x_959 = lean_box(0);
+}
+x_960 = 1;
+if (lean_is_scalar(x_959)) {
+ x_961 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_961 = x_959;
+}
+lean_ctor_set(x_961, 0, x_955);
+lean_ctor_set(x_961, 1, x_956);
+lean_ctor_set(x_961, 2, x_957);
+lean_ctor_set(x_961, 3, x_958);
+lean_ctor_set_uint8(x_961, sizeof(void*)*4, x_960);
+x_962 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_962, 0, x_954);
+lean_ctor_set(x_962, 1, x_2);
+lean_ctor_set(x_962, 2, x_3);
+lean_ctor_set(x_962, 3, x_4);
+lean_ctor_set_uint8(x_962, sizeof(void*)*4, x_960);
+x_963 = 0;
+x_964 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_964, 0, x_961);
+lean_ctor_set(x_964, 1, x_952);
+lean_ctor_set(x_964, 2, x_953);
+lean_ctor_set(x_964, 3, x_962);
+lean_ctor_set_uint8(x_964, sizeof(void*)*4, x_963);
+return x_964;
+}
+}
+else
+{
+lean_object* x_965; 
+x_965 = lean_ctor_get(x_1, 3);
 lean_inc(x_965);
-lean_inc(x_964);
-lean_dec(x_679);
-x_968 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_968, 0, x_950);
-lean_ctor_set(x_968, 1, x_951);
-lean_ctor_set(x_968, 2, x_952);
-lean_ctor_set(x_968, 3, x_953);
-lean_ctor_set_uint8(x_968, sizeof(void*)*4, x_862);
-lean_ctor_set(x_4, 3, x_968);
-lean_ctor_set(x_4, 2, x_945);
-lean_ctor_set(x_4, 1, x_944);
-lean_ctor_set(x_4, 0, x_234);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_806);
-lean_ctor_set(x_235, 3, x_964);
-lean_ctor_set(x_235, 2, x_3);
-lean_ctor_set(x_235, 1, x_2);
-lean_ctor_set(x_235, 0, x_4);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_862);
-lean_ctor_set(x_1, 3, x_807);
-lean_ctor_set(x_1, 2, x_955);
-lean_ctor_set(x_1, 1, x_954);
-lean_ctor_set(x_1, 0, x_967);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-x_969 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_969, 0, x_235);
-lean_ctor_set(x_969, 1, x_965);
-lean_ctor_set(x_969, 2, x_966);
-lean_ctor_set(x_969, 3, x_1);
-lean_ctor_set_uint8(x_969, sizeof(void*)*4, x_806);
-return x_969;
-}
+if (lean_obj_tag(x_965) == 0)
+{
+uint8_t x_966; 
+x_966 = !lean_is_exclusive(x_241);
+if (x_966 == 0)
+{
+lean_object* x_967; lean_object* x_968; lean_object* x_969; lean_object* x_970; 
+x_967 = lean_ctor_get(x_241, 3);
+lean_dec(x_967);
+x_968 = lean_ctor_get(x_241, 2);
+lean_dec(x_968);
+x_969 = lean_ctor_get(x_241, 1);
+lean_dec(x_969);
+x_970 = lean_ctor_get(x_241, 0);
+lean_dec(x_970);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_971; 
+x_971 = 1;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_3);
+lean_ctor_set(x_241, 1, x_2);
+lean_ctor_set(x_241, 0, x_1);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_971);
+return x_241;
 }
 else
 {
-lean_object* x_970; lean_object* x_971; lean_object* x_972; lean_object* x_973; lean_object* x_974; lean_object* x_975; lean_object* x_976; lean_object* x_977; lean_object* x_978; lean_object* x_979; lean_object* x_980; lean_object* x_981; lean_object* x_982; lean_object* x_983; 
-x_970 = lean_ctor_get(x_235, 0);
-x_971 = lean_ctor_get(x_235, 1);
-x_972 = lean_ctor_get(x_235, 2);
-x_973 = lean_ctor_get(x_235, 3);
-x_974 = lean_ctor_get(x_4, 1);
-x_975 = lean_ctor_get(x_4, 2);
-lean_inc(x_975);
+uint8_t x_972; 
+x_972 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_972 == 0)
+{
+lean_object* x_973; 
+x_973 = lean_ctor_get(x_4, 0);
+lean_inc(x_973);
+if (lean_obj_tag(x_973) == 0)
+{
+lean_object* x_974; 
+x_974 = lean_ctor_get(x_4, 3);
 lean_inc(x_974);
-lean_dec(x_4);
-x_976 = lean_ctor_get(x_679, 0);
-lean_inc(x_976);
-x_977 = lean_ctor_get(x_679, 1);
-lean_inc(x_977);
-x_978 = lean_ctor_get(x_679, 2);
-lean_inc(x_978);
-x_979 = lean_ctor_get(x_679, 3);
-lean_inc(x_979);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_980 = x_679;
-} else {
- lean_dec_ref(x_679);
- x_980 = lean_box(0);
-}
-if (lean_is_scalar(x_980)) {
- x_981 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_981 = x_980;
-}
-lean_ctor_set(x_981, 0, x_970);
-lean_ctor_set(x_981, 1, x_971);
-lean_ctor_set(x_981, 2, x_972);
-lean_ctor_set(x_981, 3, x_973);
-lean_ctor_set_uint8(x_981, sizeof(void*)*4, x_862);
-x_982 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_982, 0, x_234);
-lean_ctor_set(x_982, 1, x_944);
-lean_ctor_set(x_982, 2, x_945);
-lean_ctor_set(x_982, 3, x_981);
-lean_ctor_set_uint8(x_982, sizeof(void*)*4, x_806);
-lean_ctor_set(x_235, 3, x_976);
-lean_ctor_set(x_235, 2, x_3);
-lean_ctor_set(x_235, 1, x_2);
-lean_ctor_set(x_235, 0, x_982);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_862);
-lean_ctor_set(x_1, 3, x_807);
-lean_ctor_set(x_1, 2, x_975);
-lean_ctor_set(x_1, 1, x_974);
-lean_ctor_set(x_1, 0, x_979);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-x_983 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_983, 0, x_235);
-lean_ctor_set(x_983, 1, x_977);
-lean_ctor_set(x_983, 2, x_978);
-lean_ctor_set(x_983, 3, x_1);
-lean_ctor_set_uint8(x_983, sizeof(void*)*4, x_806);
-return x_983;
-}
+if (lean_obj_tag(x_974) == 0)
+{
+uint8_t x_975; 
+x_975 = 1;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_3);
+lean_ctor_set(x_241, 1, x_2);
+lean_ctor_set(x_241, 0, x_1);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_975);
+return x_241;
 }
 else
 {
-lean_object* x_984; lean_object* x_985; lean_object* x_986; lean_object* x_987; lean_object* x_988; lean_object* x_989; lean_object* x_990; lean_object* x_991; lean_object* x_992; lean_object* x_993; lean_object* x_994; lean_object* x_995; lean_object* x_996; lean_object* x_997; lean_object* x_998; lean_object* x_999; 
-x_984 = lean_ctor_get(x_235, 0);
-x_985 = lean_ctor_get(x_235, 1);
-x_986 = lean_ctor_get(x_235, 2);
-x_987 = lean_ctor_get(x_235, 3);
-lean_inc(x_987);
-lean_inc(x_986);
-lean_inc(x_985);
-lean_inc(x_984);
-lean_dec(x_235);
-x_988 = lean_ctor_get(x_4, 1);
-lean_inc(x_988);
-x_989 = lean_ctor_get(x_4, 2);
-lean_inc(x_989);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_990 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_990 = lean_box(0);
+uint8_t x_976; 
+x_976 = lean_ctor_get_uint8(x_974, sizeof(void*)*4);
+if (x_976 == 0)
+{
+uint8_t x_977; 
+x_977 = !lean_is_exclusive(x_4);
+if (x_977 == 0)
+{
+lean_object* x_978; lean_object* x_979; lean_object* x_980; lean_object* x_981; uint8_t x_982; 
+x_978 = lean_ctor_get(x_4, 1);
+x_979 = lean_ctor_get(x_4, 2);
+x_980 = lean_ctor_get(x_4, 3);
+lean_dec(x_980);
+x_981 = lean_ctor_get(x_4, 0);
+lean_dec(x_981);
+x_982 = !lean_is_exclusive(x_974);
+if (x_982 == 0)
+{
+lean_object* x_983; lean_object* x_984; lean_object* x_985; lean_object* x_986; uint8_t x_987; uint8_t x_988; 
+x_983 = lean_ctor_get(x_974, 0);
+x_984 = lean_ctor_get(x_974, 1);
+x_985 = lean_ctor_get(x_974, 2);
+x_986 = lean_ctor_get(x_974, 3);
+x_987 = 1;
+lean_ctor_set(x_974, 3, x_973);
+lean_ctor_set(x_974, 2, x_3);
+lean_ctor_set(x_974, 1, x_2);
+lean_ctor_set(x_974, 0, x_1);
+lean_ctor_set_uint8(x_974, sizeof(void*)*4, x_987);
+lean_ctor_set(x_4, 3, x_986);
+lean_ctor_set(x_4, 2, x_985);
+lean_ctor_set(x_4, 1, x_984);
+lean_ctor_set(x_4, 0, x_983);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_987);
+x_988 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_979);
+lean_ctor_set(x_241, 1, x_978);
+lean_ctor_set(x_241, 0, x_974);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_988);
+return x_241;
 }
-x_991 = lean_ctor_get(x_679, 0);
-lean_inc(x_991);
-x_992 = lean_ctor_get(x_679, 1);
+else
+{
+lean_object* x_989; lean_object* x_990; lean_object* x_991; lean_object* x_992; uint8_t x_993; lean_object* x_994; uint8_t x_995; 
+x_989 = lean_ctor_get(x_974, 0);
+x_990 = lean_ctor_get(x_974, 1);
+x_991 = lean_ctor_get(x_974, 2);
+x_992 = lean_ctor_get(x_974, 3);
 lean_inc(x_992);
-x_993 = lean_ctor_get(x_679, 2);
-lean_inc(x_993);
-x_994 = lean_ctor_get(x_679, 3);
-lean_inc(x_994);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_995 = x_679;
-} else {
- lean_dec_ref(x_679);
- x_995 = lean_box(0);
-}
-if (lean_is_scalar(x_995)) {
- x_996 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_996 = x_995;
-}
-lean_ctor_set(x_996, 0, x_984);
-lean_ctor_set(x_996, 1, x_985);
-lean_ctor_set(x_996, 2, x_986);
-lean_ctor_set(x_996, 3, x_987);
-lean_ctor_set_uint8(x_996, sizeof(void*)*4, x_862);
-if (lean_is_scalar(x_990)) {
- x_997 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_997 = x_990;
-}
-lean_ctor_set(x_997, 0, x_234);
-lean_ctor_set(x_997, 1, x_944);
-lean_ctor_set(x_997, 2, x_945);
-lean_ctor_set(x_997, 3, x_996);
-lean_ctor_set_uint8(x_997, sizeof(void*)*4, x_806);
-x_998 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_998, 0, x_997);
-lean_ctor_set(x_998, 1, x_2);
-lean_ctor_set(x_998, 2, x_3);
-lean_ctor_set(x_998, 3, x_991);
-lean_ctor_set_uint8(x_998, sizeof(void*)*4, x_862);
-lean_ctor_set(x_1, 3, x_807);
-lean_ctor_set(x_1, 2, x_989);
-lean_ctor_set(x_1, 1, x_988);
-lean_ctor_set(x_1, 0, x_994);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_862);
-x_999 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_999, 0, x_998);
-lean_ctor_set(x_999, 1, x_992);
-lean_ctor_set(x_999, 2, x_993);
-lean_ctor_set(x_999, 3, x_1);
-lean_ctor_set_uint8(x_999, sizeof(void*)*4, x_806);
-return x_999;
+lean_inc(x_991);
+lean_inc(x_990);
+lean_inc(x_989);
+lean_dec(x_974);
+x_993 = 1;
+x_994 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_994, 0, x_1);
+lean_ctor_set(x_994, 1, x_2);
+lean_ctor_set(x_994, 2, x_3);
+lean_ctor_set(x_994, 3, x_973);
+lean_ctor_set_uint8(x_994, sizeof(void*)*4, x_993);
+lean_ctor_set(x_4, 3, x_992);
+lean_ctor_set(x_4, 2, x_991);
+lean_ctor_set(x_4, 1, x_990);
+lean_ctor_set(x_4, 0, x_989);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_993);
+x_995 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_979);
+lean_ctor_set(x_241, 1, x_978);
+lean_ctor_set(x_241, 0, x_994);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_995);
+return x_241;
 }
 }
 else
 {
-lean_object* x_1000; lean_object* x_1001; lean_object* x_1002; lean_object* x_1003; lean_object* x_1004; lean_object* x_1005; lean_object* x_1006; lean_object* x_1007; lean_object* x_1008; lean_object* x_1009; lean_object* x_1010; lean_object* x_1011; lean_object* x_1012; lean_object* x_1013; lean_object* x_1014; lean_object* x_1015; lean_object* x_1016; lean_object* x_1017; lean_object* x_1018; lean_object* x_1019; 
-x_1000 = lean_ctor_get(x_1, 1);
-x_1001 = lean_ctor_get(x_1, 2);
-lean_inc(x_1001);
-lean_inc(x_1000);
-lean_dec(x_1);
-x_1002 = lean_ctor_get(x_235, 0);
-lean_inc(x_1002);
-x_1003 = lean_ctor_get(x_235, 1);
-lean_inc(x_1003);
-x_1004 = lean_ctor_get(x_235, 2);
-lean_inc(x_1004);
-x_1005 = lean_ctor_get(x_235, 3);
-lean_inc(x_1005);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_1006 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_1006 = lean_box(0);
-}
-x_1007 = lean_ctor_get(x_4, 1);
-lean_inc(x_1007);
-x_1008 = lean_ctor_get(x_4, 2);
-lean_inc(x_1008);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1009 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1009 = lean_box(0);
-}
-x_1010 = lean_ctor_get(x_679, 0);
-lean_inc(x_1010);
-x_1011 = lean_ctor_get(x_679, 1);
-lean_inc(x_1011);
-x_1012 = lean_ctor_get(x_679, 2);
-lean_inc(x_1012);
-x_1013 = lean_ctor_get(x_679, 3);
-lean_inc(x_1013);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_1014 = x_679;
-} else {
- lean_dec_ref(x_679);
- x_1014 = lean_box(0);
-}
-if (lean_is_scalar(x_1014)) {
- x_1015 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1015 = x_1014;
-}
-lean_ctor_set(x_1015, 0, x_1002);
-lean_ctor_set(x_1015, 1, x_1003);
-lean_ctor_set(x_1015, 2, x_1004);
-lean_ctor_set(x_1015, 3, x_1005);
-lean_ctor_set_uint8(x_1015, sizeof(void*)*4, x_862);
-if (lean_is_scalar(x_1009)) {
- x_1016 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1016 = x_1009;
-}
-lean_ctor_set(x_1016, 0, x_234);
-lean_ctor_set(x_1016, 1, x_1000);
-lean_ctor_set(x_1016, 2, x_1001);
-lean_ctor_set(x_1016, 3, x_1015);
-lean_ctor_set_uint8(x_1016, sizeof(void*)*4, x_806);
-if (lean_is_scalar(x_1006)) {
- x_1017 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1017 = x_1006;
-}
-lean_ctor_set(x_1017, 0, x_1016);
-lean_ctor_set(x_1017, 1, x_2);
-lean_ctor_set(x_1017, 2, x_3);
-lean_ctor_set(x_1017, 3, x_1010);
-lean_ctor_set_uint8(x_1017, sizeof(void*)*4, x_862);
-x_1018 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1018, 0, x_1013);
-lean_ctor_set(x_1018, 1, x_1007);
-lean_ctor_set(x_1018, 2, x_1008);
-lean_ctor_set(x_1018, 3, x_807);
-lean_ctor_set_uint8(x_1018, sizeof(void*)*4, x_862);
-x_1019 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1019, 0, x_1017);
-lean_ctor_set(x_1019, 1, x_1011);
-lean_ctor_set(x_1019, 2, x_1012);
-lean_ctor_set(x_1019, 3, x_1018);
-lean_ctor_set_uint8(x_1019, sizeof(void*)*4, x_806);
-return x_1019;
-}
-}
-}
-}
-else
-{
-lean_object* x_1020; 
-x_1020 = lean_ctor_get(x_4, 3);
-lean_inc(x_1020);
-if (lean_obj_tag(x_1020) == 0)
-{
-uint8_t x_1021; 
-x_1021 = !lean_is_exclusive(x_679);
-if (x_1021 == 0)
-{
-lean_object* x_1022; lean_object* x_1023; lean_object* x_1024; lean_object* x_1025; uint8_t x_1026; 
-x_1022 = lean_ctor_get(x_679, 3);
-lean_dec(x_1022);
-x_1023 = lean_ctor_get(x_679, 2);
-lean_dec(x_1023);
-x_1024 = lean_ctor_get(x_679, 1);
-lean_dec(x_1024);
-x_1025 = lean_ctor_get(x_679, 0);
-lean_dec(x_1025);
-x_1026 = !lean_is_exclusive(x_1);
-if (x_1026 == 0)
-{
-lean_object* x_1027; lean_object* x_1028; lean_object* x_1029; lean_object* x_1030; uint8_t x_1031; 
-x_1027 = lean_ctor_get(x_1, 1);
-x_1028 = lean_ctor_get(x_1, 2);
-x_1029 = lean_ctor_get(x_1, 3);
-lean_dec(x_1029);
-x_1030 = lean_ctor_get(x_1, 0);
-lean_dec(x_1030);
-x_1031 = !lean_is_exclusive(x_235);
-if (x_1031 == 0)
-{
-lean_object* x_1032; lean_object* x_1033; lean_object* x_1034; lean_object* x_1035; 
-x_1032 = lean_ctor_get(x_235, 0);
-x_1033 = lean_ctor_get(x_235, 1);
-x_1034 = lean_ctor_get(x_235, 2);
-x_1035 = lean_ctor_get(x_235, 3);
-lean_ctor_set(x_679, 3, x_1035);
-lean_ctor_set(x_679, 2, x_1034);
-lean_ctor_set(x_679, 1, x_1033);
-lean_ctor_set(x_679, 0, x_1032);
-lean_ctor_set(x_235, 3, x_679);
-lean_ctor_set(x_235, 2, x_1028);
-lean_ctor_set(x_235, 1, x_1027);
-lean_ctor_set(x_235, 0, x_1020);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_235);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-return x_1;
-}
-else
-{
-lean_object* x_1036; lean_object* x_1037; lean_object* x_1038; lean_object* x_1039; lean_object* x_1040; 
-x_1036 = lean_ctor_get(x_235, 0);
-x_1037 = lean_ctor_get(x_235, 1);
-x_1038 = lean_ctor_get(x_235, 2);
-x_1039 = lean_ctor_get(x_235, 3);
-lean_inc(x_1039);
-lean_inc(x_1038);
-lean_inc(x_1037);
-lean_inc(x_1036);
-lean_dec(x_235);
-lean_ctor_set(x_679, 3, x_1039);
-lean_ctor_set(x_679, 2, x_1038);
-lean_ctor_set(x_679, 1, x_1037);
-lean_ctor_set(x_679, 0, x_1036);
-x_1040 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1040, 0, x_1020);
-lean_ctor_set(x_1040, 1, x_1027);
-lean_ctor_set(x_1040, 2, x_1028);
-lean_ctor_set(x_1040, 3, x_679);
-lean_ctor_set_uint8(x_1040, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_1040);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-return x_1;
-}
-}
-else
-{
-lean_object* x_1041; lean_object* x_1042; lean_object* x_1043; lean_object* x_1044; lean_object* x_1045; lean_object* x_1046; lean_object* x_1047; lean_object* x_1048; lean_object* x_1049; 
-x_1041 = lean_ctor_get(x_1, 1);
-x_1042 = lean_ctor_get(x_1, 2);
-lean_inc(x_1042);
-lean_inc(x_1041);
-lean_dec(x_1);
-x_1043 = lean_ctor_get(x_235, 0);
-lean_inc(x_1043);
-x_1044 = lean_ctor_get(x_235, 1);
-lean_inc(x_1044);
-x_1045 = lean_ctor_get(x_235, 2);
-lean_inc(x_1045);
-x_1046 = lean_ctor_get(x_235, 3);
-lean_inc(x_1046);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_1047 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_1047 = lean_box(0);
-}
-lean_ctor_set(x_679, 3, x_1046);
-lean_ctor_set(x_679, 2, x_1045);
-lean_ctor_set(x_679, 1, x_1044);
-lean_ctor_set(x_679, 0, x_1043);
-if (lean_is_scalar(x_1047)) {
- x_1048 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1048 = x_1047;
-}
-lean_ctor_set(x_1048, 0, x_1020);
-lean_ctor_set(x_1048, 1, x_1041);
-lean_ctor_set(x_1048, 2, x_1042);
-lean_ctor_set(x_1048, 3, x_679);
-lean_ctor_set_uint8(x_1048, sizeof(void*)*4, x_678);
-x_1049 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1049, 0, x_1048);
-lean_ctor_set(x_1049, 1, x_2);
-lean_ctor_set(x_1049, 2, x_3);
-lean_ctor_set(x_1049, 3, x_4);
-lean_ctor_set_uint8(x_1049, sizeof(void*)*4, x_806);
-return x_1049;
-}
-}
-else
-{
-lean_object* x_1050; lean_object* x_1051; lean_object* x_1052; lean_object* x_1053; lean_object* x_1054; lean_object* x_1055; lean_object* x_1056; lean_object* x_1057; lean_object* x_1058; lean_object* x_1059; lean_object* x_1060; 
-lean_dec(x_679);
-x_1050 = lean_ctor_get(x_1, 1);
-lean_inc(x_1050);
-x_1051 = lean_ctor_get(x_1, 2);
-lean_inc(x_1051);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_1052 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_1052 = lean_box(0);
-}
-x_1053 = lean_ctor_get(x_235, 0);
-lean_inc(x_1053);
-x_1054 = lean_ctor_get(x_235, 1);
-lean_inc(x_1054);
-x_1055 = lean_ctor_get(x_235, 2);
-lean_inc(x_1055);
-x_1056 = lean_ctor_get(x_235, 3);
-lean_inc(x_1056);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_1057 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_1057 = lean_box(0);
-}
-x_1058 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1058, 0, x_1053);
-lean_ctor_set(x_1058, 1, x_1054);
-lean_ctor_set(x_1058, 2, x_1055);
-lean_ctor_set(x_1058, 3, x_1056);
-lean_ctor_set_uint8(x_1058, sizeof(void*)*4, x_806);
-if (lean_is_scalar(x_1057)) {
- x_1059 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1059 = x_1057;
-}
-lean_ctor_set(x_1059, 0, x_1020);
-lean_ctor_set(x_1059, 1, x_1050);
-lean_ctor_set(x_1059, 2, x_1051);
-lean_ctor_set(x_1059, 3, x_1058);
-lean_ctor_set_uint8(x_1059, sizeof(void*)*4, x_678);
-if (lean_is_scalar(x_1052)) {
- x_1060 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1060 = x_1052;
-}
-lean_ctor_set(x_1060, 0, x_1059);
-lean_ctor_set(x_1060, 1, x_2);
-lean_ctor_set(x_1060, 2, x_3);
-lean_ctor_set(x_1060, 3, x_4);
-lean_ctor_set_uint8(x_1060, sizeof(void*)*4, x_806);
-return x_1060;
-}
-}
-else
-{
-uint8_t x_1061; 
-x_1061 = lean_ctor_get_uint8(x_1020, sizeof(void*)*4);
-if (x_1061 == 0)
-{
-uint8_t x_1062; 
-x_1062 = !lean_is_exclusive(x_1);
-if (x_1062 == 0)
-{
-lean_object* x_1063; lean_object* x_1064; lean_object* x_1065; lean_object* x_1066; uint8_t x_1067; 
-x_1063 = lean_ctor_get(x_1, 1);
-x_1064 = lean_ctor_get(x_1, 2);
-x_1065 = lean_ctor_get(x_1, 3);
-lean_dec(x_1065);
-x_1066 = lean_ctor_get(x_1, 0);
-lean_dec(x_1066);
-x_1067 = !lean_is_exclusive(x_235);
-if (x_1067 == 0)
-{
-uint8_t x_1068; 
-x_1068 = !lean_is_exclusive(x_4);
-if (x_1068 == 0)
-{
-lean_object* x_1069; lean_object* x_1070; lean_object* x_1071; lean_object* x_1072; lean_object* x_1073; lean_object* x_1074; lean_object* x_1075; lean_object* x_1076; uint8_t x_1077; 
-x_1069 = lean_ctor_get(x_235, 0);
-x_1070 = lean_ctor_get(x_235, 1);
-x_1071 = lean_ctor_get(x_235, 2);
-x_1072 = lean_ctor_get(x_235, 3);
-x_1073 = lean_ctor_get(x_4, 1);
-x_1074 = lean_ctor_get(x_4, 2);
-x_1075 = lean_ctor_get(x_4, 3);
-lean_dec(x_1075);
-x_1076 = lean_ctor_get(x_4, 0);
-lean_dec(x_1076);
-x_1077 = !lean_is_exclusive(x_1020);
-if (x_1077 == 0)
-{
-lean_object* x_1078; lean_object* x_1079; lean_object* x_1080; lean_object* x_1081; lean_object* x_1082; 
-x_1078 = lean_ctor_get(x_1020, 0);
-x_1079 = lean_ctor_get(x_1020, 1);
-x_1080 = lean_ctor_get(x_1020, 2);
-x_1081 = lean_ctor_get(x_1020, 3);
-lean_ctor_set(x_1020, 3, x_1072);
-lean_ctor_set(x_1020, 2, x_1071);
-lean_ctor_set(x_1020, 1, x_1070);
-lean_ctor_set(x_1020, 0, x_1069);
-lean_ctor_set_uint8(x_1020, sizeof(void*)*4, x_806);
-lean_ctor_set(x_4, 2, x_1064);
-lean_ctor_set(x_4, 1, x_1063);
-lean_ctor_set(x_4, 0, x_234);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_235, 3, x_679);
-lean_ctor_set(x_235, 2, x_3);
-lean_ctor_set(x_235, 1, x_2);
-lean_ctor_set(x_235, 0, x_4);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_806);
-lean_ctor_set(x_1, 3, x_1081);
-lean_ctor_set(x_1, 2, x_1080);
-lean_ctor_set(x_1, 1, x_1079);
-lean_ctor_set(x_1, 0, x_1078);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-x_1082 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1082, 0, x_235);
-lean_ctor_set(x_1082, 1, x_1073);
-lean_ctor_set(x_1082, 2, x_1074);
-lean_ctor_set(x_1082, 3, x_1);
-lean_ctor_set_uint8(x_1082, sizeof(void*)*4, x_1061);
-return x_1082;
-}
-else
-{
-lean_object* x_1083; lean_object* x_1084; lean_object* x_1085; lean_object* x_1086; lean_object* x_1087; lean_object* x_1088; 
-x_1083 = lean_ctor_get(x_1020, 0);
-x_1084 = lean_ctor_get(x_1020, 1);
-x_1085 = lean_ctor_get(x_1020, 2);
-x_1086 = lean_ctor_get(x_1020, 3);
-lean_inc(x_1086);
-lean_inc(x_1085);
-lean_inc(x_1084);
-lean_inc(x_1083);
-lean_dec(x_1020);
-x_1087 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1087, 0, x_1069);
-lean_ctor_set(x_1087, 1, x_1070);
-lean_ctor_set(x_1087, 2, x_1071);
-lean_ctor_set(x_1087, 3, x_1072);
-lean_ctor_set_uint8(x_1087, sizeof(void*)*4, x_806);
-lean_ctor_set(x_4, 3, x_1087);
-lean_ctor_set(x_4, 2, x_1064);
-lean_ctor_set(x_4, 1, x_1063);
-lean_ctor_set(x_4, 0, x_234);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_235, 3, x_679);
-lean_ctor_set(x_235, 2, x_3);
-lean_ctor_set(x_235, 1, x_2);
-lean_ctor_set(x_235, 0, x_4);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_806);
-lean_ctor_set(x_1, 3, x_1086);
-lean_ctor_set(x_1, 2, x_1085);
-lean_ctor_set(x_1, 1, x_1084);
-lean_ctor_set(x_1, 0, x_1083);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-x_1088 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1088, 0, x_235);
-lean_ctor_set(x_1088, 1, x_1073);
-lean_ctor_set(x_1088, 2, x_1074);
-lean_ctor_set(x_1088, 3, x_1);
-lean_ctor_set_uint8(x_1088, sizeof(void*)*4, x_1061);
-return x_1088;
-}
-}
-else
-{
-lean_object* x_1089; lean_object* x_1090; lean_object* x_1091; lean_object* x_1092; lean_object* x_1093; lean_object* x_1094; lean_object* x_1095; lean_object* x_1096; lean_object* x_1097; lean_object* x_1098; lean_object* x_1099; lean_object* x_1100; lean_object* x_1101; lean_object* x_1102; 
-x_1089 = lean_ctor_get(x_235, 0);
-x_1090 = lean_ctor_get(x_235, 1);
-x_1091 = lean_ctor_get(x_235, 2);
-x_1092 = lean_ctor_get(x_235, 3);
-x_1093 = lean_ctor_get(x_4, 1);
-x_1094 = lean_ctor_get(x_4, 2);
-lean_inc(x_1094);
-lean_inc(x_1093);
+lean_object* x_996; lean_object* x_997; lean_object* x_998; lean_object* x_999; lean_object* x_1000; lean_object* x_1001; lean_object* x_1002; uint8_t x_1003; lean_object* x_1004; lean_object* x_1005; uint8_t x_1006; 
+x_996 = lean_ctor_get(x_4, 1);
+x_997 = lean_ctor_get(x_4, 2);
+lean_inc(x_997);
+lean_inc(x_996);
 lean_dec(x_4);
-x_1095 = lean_ctor_get(x_1020, 0);
+x_998 = lean_ctor_get(x_974, 0);
+lean_inc(x_998);
+x_999 = lean_ctor_get(x_974, 1);
+lean_inc(x_999);
+x_1000 = lean_ctor_get(x_974, 2);
+lean_inc(x_1000);
+x_1001 = lean_ctor_get(x_974, 3);
+lean_inc(x_1001);
+if (lean_is_exclusive(x_974)) {
+ lean_ctor_release(x_974, 0);
+ lean_ctor_release(x_974, 1);
+ lean_ctor_release(x_974, 2);
+ lean_ctor_release(x_974, 3);
+ x_1002 = x_974;
+} else {
+ lean_dec_ref(x_974);
+ x_1002 = lean_box(0);
+}
+x_1003 = 1;
+if (lean_is_scalar(x_1002)) {
+ x_1004 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1004 = x_1002;
+}
+lean_ctor_set(x_1004, 0, x_1);
+lean_ctor_set(x_1004, 1, x_2);
+lean_ctor_set(x_1004, 2, x_3);
+lean_ctor_set(x_1004, 3, x_973);
+lean_ctor_set_uint8(x_1004, sizeof(void*)*4, x_1003);
+x_1005 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1005, 0, x_998);
+lean_ctor_set(x_1005, 1, x_999);
+lean_ctor_set(x_1005, 2, x_1000);
+lean_ctor_set(x_1005, 3, x_1001);
+lean_ctor_set_uint8(x_1005, sizeof(void*)*4, x_1003);
+x_1006 = 0;
+lean_ctor_set(x_241, 3, x_1005);
+lean_ctor_set(x_241, 2, x_997);
+lean_ctor_set(x_241, 1, x_996);
+lean_ctor_set(x_241, 0, x_1004);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1006);
+return x_241;
+}
+}
+else
+{
+uint8_t x_1007; 
+lean_free_object(x_241);
+x_1007 = !lean_is_exclusive(x_974);
+if (x_1007 == 0)
+{
+lean_object* x_1008; lean_object* x_1009; lean_object* x_1010; lean_object* x_1011; uint8_t x_1012; 
+x_1008 = lean_ctor_get(x_974, 3);
+lean_dec(x_1008);
+x_1009 = lean_ctor_get(x_974, 2);
+lean_dec(x_1009);
+x_1010 = lean_ctor_get(x_974, 1);
+lean_dec(x_1010);
+x_1011 = lean_ctor_get(x_974, 0);
+lean_dec(x_1011);
+x_1012 = 1;
+lean_ctor_set(x_974, 3, x_4);
+lean_ctor_set(x_974, 2, x_3);
+lean_ctor_set(x_974, 1, x_2);
+lean_ctor_set(x_974, 0, x_1);
+lean_ctor_set_uint8(x_974, sizeof(void*)*4, x_1012);
+return x_974;
+}
+else
+{
+uint8_t x_1013; lean_object* x_1014; 
+lean_dec(x_974);
+x_1013 = 1;
+x_1014 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1014, 0, x_1);
+lean_ctor_set(x_1014, 1, x_2);
+lean_ctor_set(x_1014, 2, x_3);
+lean_ctor_set(x_1014, 3, x_4);
+lean_ctor_set_uint8(x_1014, sizeof(void*)*4, x_1013);
+return x_1014;
+}
+}
+}
+}
+else
+{
+uint8_t x_1015; 
+x_1015 = lean_ctor_get_uint8(x_973, sizeof(void*)*4);
+if (x_1015 == 0)
+{
+lean_object* x_1016; 
+x_1016 = lean_ctor_get(x_4, 3);
+lean_inc(x_1016);
+if (lean_obj_tag(x_1016) == 0)
+{
+uint8_t x_1017; 
+x_1017 = !lean_is_exclusive(x_4);
+if (x_1017 == 0)
+{
+lean_object* x_1018; lean_object* x_1019; uint8_t x_1020; 
+x_1018 = lean_ctor_get(x_4, 3);
+lean_dec(x_1018);
+x_1019 = lean_ctor_get(x_4, 0);
+lean_dec(x_1019);
+x_1020 = !lean_is_exclusive(x_973);
+if (x_1020 == 0)
+{
+lean_object* x_1021; lean_object* x_1022; lean_object* x_1023; lean_object* x_1024; uint8_t x_1025; uint8_t x_1026; 
+x_1021 = lean_ctor_get(x_973, 0);
+x_1022 = lean_ctor_get(x_973, 1);
+x_1023 = lean_ctor_get(x_973, 2);
+x_1024 = lean_ctor_get(x_973, 3);
+x_1025 = 1;
+lean_ctor_set(x_973, 3, x_1021);
+lean_ctor_set(x_973, 2, x_3);
+lean_ctor_set(x_973, 1, x_2);
+lean_ctor_set(x_973, 0, x_1);
+lean_ctor_set_uint8(x_973, sizeof(void*)*4, x_1025);
+lean_ctor_set(x_4, 0, x_1024);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1025);
+x_1026 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_1023);
+lean_ctor_set(x_241, 1, x_1022);
+lean_ctor_set(x_241, 0, x_973);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1026);
+return x_241;
+}
+else
+{
+lean_object* x_1027; lean_object* x_1028; lean_object* x_1029; lean_object* x_1030; uint8_t x_1031; lean_object* x_1032; uint8_t x_1033; 
+x_1027 = lean_ctor_get(x_973, 0);
+x_1028 = lean_ctor_get(x_973, 1);
+x_1029 = lean_ctor_get(x_973, 2);
+x_1030 = lean_ctor_get(x_973, 3);
+lean_inc(x_1030);
+lean_inc(x_1029);
+lean_inc(x_1028);
+lean_inc(x_1027);
+lean_dec(x_973);
+x_1031 = 1;
+x_1032 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1032, 0, x_1);
+lean_ctor_set(x_1032, 1, x_2);
+lean_ctor_set(x_1032, 2, x_3);
+lean_ctor_set(x_1032, 3, x_1027);
+lean_ctor_set_uint8(x_1032, sizeof(void*)*4, x_1031);
+lean_ctor_set(x_4, 0, x_1030);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1031);
+x_1033 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_1029);
+lean_ctor_set(x_241, 1, x_1028);
+lean_ctor_set(x_241, 0, x_1032);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1033);
+return x_241;
+}
+}
+else
+{
+lean_object* x_1034; lean_object* x_1035; lean_object* x_1036; lean_object* x_1037; lean_object* x_1038; lean_object* x_1039; lean_object* x_1040; uint8_t x_1041; lean_object* x_1042; lean_object* x_1043; uint8_t x_1044; 
+x_1034 = lean_ctor_get(x_4, 1);
+x_1035 = lean_ctor_get(x_4, 2);
+lean_inc(x_1035);
+lean_inc(x_1034);
+lean_dec(x_4);
+x_1036 = lean_ctor_get(x_973, 0);
+lean_inc(x_1036);
+x_1037 = lean_ctor_get(x_973, 1);
+lean_inc(x_1037);
+x_1038 = lean_ctor_get(x_973, 2);
+lean_inc(x_1038);
+x_1039 = lean_ctor_get(x_973, 3);
+lean_inc(x_1039);
+if (lean_is_exclusive(x_973)) {
+ lean_ctor_release(x_973, 0);
+ lean_ctor_release(x_973, 1);
+ lean_ctor_release(x_973, 2);
+ lean_ctor_release(x_973, 3);
+ x_1040 = x_973;
+} else {
+ lean_dec_ref(x_973);
+ x_1040 = lean_box(0);
+}
+x_1041 = 1;
+if (lean_is_scalar(x_1040)) {
+ x_1042 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1042 = x_1040;
+}
+lean_ctor_set(x_1042, 0, x_1);
+lean_ctor_set(x_1042, 1, x_2);
+lean_ctor_set(x_1042, 2, x_3);
+lean_ctor_set(x_1042, 3, x_1036);
+lean_ctor_set_uint8(x_1042, sizeof(void*)*4, x_1041);
+x_1043 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1043, 0, x_1039);
+lean_ctor_set(x_1043, 1, x_1034);
+lean_ctor_set(x_1043, 2, x_1035);
+lean_ctor_set(x_1043, 3, x_1016);
+lean_ctor_set_uint8(x_1043, sizeof(void*)*4, x_1041);
+x_1044 = 0;
+lean_ctor_set(x_241, 3, x_1043);
+lean_ctor_set(x_241, 2, x_1038);
+lean_ctor_set(x_241, 1, x_1037);
+lean_ctor_set(x_241, 0, x_1042);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1044);
+return x_241;
+}
+}
+else
+{
+uint8_t x_1045; 
+x_1045 = lean_ctor_get_uint8(x_1016, sizeof(void*)*4);
+if (x_1045 == 0)
+{
+uint8_t x_1046; 
+x_1046 = !lean_is_exclusive(x_4);
+if (x_1046 == 0)
+{
+lean_object* x_1047; lean_object* x_1048; lean_object* x_1049; lean_object* x_1050; uint8_t x_1051; 
+x_1047 = lean_ctor_get(x_4, 1);
+x_1048 = lean_ctor_get(x_4, 2);
+x_1049 = lean_ctor_get(x_4, 3);
+lean_dec(x_1049);
+x_1050 = lean_ctor_get(x_4, 0);
+lean_dec(x_1050);
+x_1051 = !lean_is_exclusive(x_973);
+if (x_1051 == 0)
+{
+uint8_t x_1052; 
+x_1052 = !lean_is_exclusive(x_1016);
+if (x_1052 == 0)
+{
+lean_object* x_1053; lean_object* x_1054; lean_object* x_1055; lean_object* x_1056; lean_object* x_1057; lean_object* x_1058; lean_object* x_1059; lean_object* x_1060; uint8_t x_1061; uint8_t x_1062; 
+x_1053 = lean_ctor_get(x_973, 0);
+x_1054 = lean_ctor_get(x_973, 1);
+x_1055 = lean_ctor_get(x_973, 2);
+x_1056 = lean_ctor_get(x_973, 3);
+x_1057 = lean_ctor_get(x_1016, 0);
+x_1058 = lean_ctor_get(x_1016, 1);
+x_1059 = lean_ctor_get(x_1016, 2);
+x_1060 = lean_ctor_get(x_1016, 3);
+lean_ctor_set(x_1016, 3, x_1056);
+lean_ctor_set(x_1016, 2, x_1055);
+lean_ctor_set(x_1016, 1, x_1054);
+lean_ctor_set(x_1016, 0, x_1053);
+x_1061 = 1;
+lean_ctor_set(x_973, 3, x_1016);
+lean_ctor_set(x_973, 2, x_3);
+lean_ctor_set(x_973, 1, x_2);
+lean_ctor_set(x_973, 0, x_1);
+lean_ctor_set_uint8(x_973, sizeof(void*)*4, x_1061);
+lean_ctor_set(x_4, 3, x_1060);
+lean_ctor_set(x_4, 2, x_1059);
+lean_ctor_set(x_4, 1, x_1058);
+lean_ctor_set(x_4, 0, x_1057);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1061);
+x_1062 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_1048);
+lean_ctor_set(x_241, 1, x_1047);
+lean_ctor_set(x_241, 0, x_973);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1062);
+return x_241;
+}
+else
+{
+lean_object* x_1063; lean_object* x_1064; lean_object* x_1065; lean_object* x_1066; lean_object* x_1067; lean_object* x_1068; lean_object* x_1069; lean_object* x_1070; lean_object* x_1071; uint8_t x_1072; uint8_t x_1073; 
+x_1063 = lean_ctor_get(x_973, 0);
+x_1064 = lean_ctor_get(x_973, 1);
+x_1065 = lean_ctor_get(x_973, 2);
+x_1066 = lean_ctor_get(x_973, 3);
+x_1067 = lean_ctor_get(x_1016, 0);
+x_1068 = lean_ctor_get(x_1016, 1);
+x_1069 = lean_ctor_get(x_1016, 2);
+x_1070 = lean_ctor_get(x_1016, 3);
+lean_inc(x_1070);
+lean_inc(x_1069);
+lean_inc(x_1068);
+lean_inc(x_1067);
+lean_dec(x_1016);
+x_1071 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1071, 0, x_1063);
+lean_ctor_set(x_1071, 1, x_1064);
+lean_ctor_set(x_1071, 2, x_1065);
+lean_ctor_set(x_1071, 3, x_1066);
+lean_ctor_set_uint8(x_1071, sizeof(void*)*4, x_1045);
+x_1072 = 1;
+lean_ctor_set(x_973, 3, x_1071);
+lean_ctor_set(x_973, 2, x_3);
+lean_ctor_set(x_973, 1, x_2);
+lean_ctor_set(x_973, 0, x_1);
+lean_ctor_set_uint8(x_973, sizeof(void*)*4, x_1072);
+lean_ctor_set(x_4, 3, x_1070);
+lean_ctor_set(x_4, 2, x_1069);
+lean_ctor_set(x_4, 1, x_1068);
+lean_ctor_set(x_4, 0, x_1067);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1072);
+x_1073 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_1048);
+lean_ctor_set(x_241, 1, x_1047);
+lean_ctor_set(x_241, 0, x_973);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1073);
+return x_241;
+}
+}
+else
+{
+lean_object* x_1074; lean_object* x_1075; lean_object* x_1076; lean_object* x_1077; lean_object* x_1078; lean_object* x_1079; lean_object* x_1080; lean_object* x_1081; lean_object* x_1082; lean_object* x_1083; uint8_t x_1084; lean_object* x_1085; uint8_t x_1086; 
+x_1074 = lean_ctor_get(x_973, 0);
+x_1075 = lean_ctor_get(x_973, 1);
+x_1076 = lean_ctor_get(x_973, 2);
+x_1077 = lean_ctor_get(x_973, 3);
+lean_inc(x_1077);
+lean_inc(x_1076);
+lean_inc(x_1075);
+lean_inc(x_1074);
+lean_dec(x_973);
+x_1078 = lean_ctor_get(x_1016, 0);
+lean_inc(x_1078);
+x_1079 = lean_ctor_get(x_1016, 1);
+lean_inc(x_1079);
+x_1080 = lean_ctor_get(x_1016, 2);
+lean_inc(x_1080);
+x_1081 = lean_ctor_get(x_1016, 3);
+lean_inc(x_1081);
+if (lean_is_exclusive(x_1016)) {
+ lean_ctor_release(x_1016, 0);
+ lean_ctor_release(x_1016, 1);
+ lean_ctor_release(x_1016, 2);
+ lean_ctor_release(x_1016, 3);
+ x_1082 = x_1016;
+} else {
+ lean_dec_ref(x_1016);
+ x_1082 = lean_box(0);
+}
+if (lean_is_scalar(x_1082)) {
+ x_1083 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1083 = x_1082;
+}
+lean_ctor_set(x_1083, 0, x_1074);
+lean_ctor_set(x_1083, 1, x_1075);
+lean_ctor_set(x_1083, 2, x_1076);
+lean_ctor_set(x_1083, 3, x_1077);
+lean_ctor_set_uint8(x_1083, sizeof(void*)*4, x_1045);
+x_1084 = 1;
+x_1085 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1085, 0, x_1);
+lean_ctor_set(x_1085, 1, x_2);
+lean_ctor_set(x_1085, 2, x_3);
+lean_ctor_set(x_1085, 3, x_1083);
+lean_ctor_set_uint8(x_1085, sizeof(void*)*4, x_1084);
+lean_ctor_set(x_4, 3, x_1081);
+lean_ctor_set(x_4, 2, x_1080);
+lean_ctor_set(x_4, 1, x_1079);
+lean_ctor_set(x_4, 0, x_1078);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1084);
+x_1086 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_1048);
+lean_ctor_set(x_241, 1, x_1047);
+lean_ctor_set(x_241, 0, x_1085);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1086);
+return x_241;
+}
+}
+else
+{
+lean_object* x_1087; lean_object* x_1088; lean_object* x_1089; lean_object* x_1090; lean_object* x_1091; lean_object* x_1092; lean_object* x_1093; lean_object* x_1094; lean_object* x_1095; lean_object* x_1096; lean_object* x_1097; lean_object* x_1098; lean_object* x_1099; uint8_t x_1100; lean_object* x_1101; lean_object* x_1102; uint8_t x_1103; 
+x_1087 = lean_ctor_get(x_4, 1);
+x_1088 = lean_ctor_get(x_4, 2);
+lean_inc(x_1088);
+lean_inc(x_1087);
+lean_dec(x_4);
+x_1089 = lean_ctor_get(x_973, 0);
+lean_inc(x_1089);
+x_1090 = lean_ctor_get(x_973, 1);
+lean_inc(x_1090);
+x_1091 = lean_ctor_get(x_973, 2);
+lean_inc(x_1091);
+x_1092 = lean_ctor_get(x_973, 3);
+lean_inc(x_1092);
+if (lean_is_exclusive(x_973)) {
+ lean_ctor_release(x_973, 0);
+ lean_ctor_release(x_973, 1);
+ lean_ctor_release(x_973, 2);
+ lean_ctor_release(x_973, 3);
+ x_1093 = x_973;
+} else {
+ lean_dec_ref(x_973);
+ x_1093 = lean_box(0);
+}
+x_1094 = lean_ctor_get(x_1016, 0);
+lean_inc(x_1094);
+x_1095 = lean_ctor_get(x_1016, 1);
 lean_inc(x_1095);
-x_1096 = lean_ctor_get(x_1020, 1);
+x_1096 = lean_ctor_get(x_1016, 2);
 lean_inc(x_1096);
-x_1097 = lean_ctor_get(x_1020, 2);
+x_1097 = lean_ctor_get(x_1016, 3);
 lean_inc(x_1097);
-x_1098 = lean_ctor_get(x_1020, 3);
-lean_inc(x_1098);
-if (lean_is_exclusive(x_1020)) {
- lean_ctor_release(x_1020, 0);
- lean_ctor_release(x_1020, 1);
- lean_ctor_release(x_1020, 2);
- lean_ctor_release(x_1020, 3);
- x_1099 = x_1020;
+if (lean_is_exclusive(x_1016)) {
+ lean_ctor_release(x_1016, 0);
+ lean_ctor_release(x_1016, 1);
+ lean_ctor_release(x_1016, 2);
+ lean_ctor_release(x_1016, 3);
+ x_1098 = x_1016;
 } else {
- lean_dec_ref(x_1020);
- x_1099 = lean_box(0);
+ lean_dec_ref(x_1016);
+ x_1098 = lean_box(0);
 }
-if (lean_is_scalar(x_1099)) {
- x_1100 = lean_alloc_ctor(1, 4, 1);
+if (lean_is_scalar(x_1098)) {
+ x_1099 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1100 = x_1099;
+ x_1099 = x_1098;
 }
-lean_ctor_set(x_1100, 0, x_1089);
-lean_ctor_set(x_1100, 1, x_1090);
-lean_ctor_set(x_1100, 2, x_1091);
-lean_ctor_set(x_1100, 3, x_1092);
-lean_ctor_set_uint8(x_1100, sizeof(void*)*4, x_806);
-x_1101 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1101, 0, x_234);
-lean_ctor_set(x_1101, 1, x_1063);
-lean_ctor_set(x_1101, 2, x_1064);
-lean_ctor_set(x_1101, 3, x_1100);
-lean_ctor_set_uint8(x_1101, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_235, 3, x_679);
-lean_ctor_set(x_235, 2, x_3);
-lean_ctor_set(x_235, 1, x_2);
-lean_ctor_set(x_235, 0, x_1101);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_806);
-lean_ctor_set(x_1, 3, x_1098);
-lean_ctor_set(x_1, 2, x_1097);
-lean_ctor_set(x_1, 1, x_1096);
-lean_ctor_set(x_1, 0, x_1095);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
+lean_ctor_set(x_1099, 0, x_1089);
+lean_ctor_set(x_1099, 1, x_1090);
+lean_ctor_set(x_1099, 2, x_1091);
+lean_ctor_set(x_1099, 3, x_1092);
+lean_ctor_set_uint8(x_1099, sizeof(void*)*4, x_1045);
+x_1100 = 1;
+if (lean_is_scalar(x_1093)) {
+ x_1101 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1101 = x_1093;
+}
+lean_ctor_set(x_1101, 0, x_1);
+lean_ctor_set(x_1101, 1, x_2);
+lean_ctor_set(x_1101, 2, x_3);
+lean_ctor_set(x_1101, 3, x_1099);
+lean_ctor_set_uint8(x_1101, sizeof(void*)*4, x_1100);
 x_1102 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1102, 0, x_235);
-lean_ctor_set(x_1102, 1, x_1093);
-lean_ctor_set(x_1102, 2, x_1094);
-lean_ctor_set(x_1102, 3, x_1);
-lean_ctor_set_uint8(x_1102, sizeof(void*)*4, x_1061);
-return x_1102;
+lean_ctor_set(x_1102, 0, x_1094);
+lean_ctor_set(x_1102, 1, x_1095);
+lean_ctor_set(x_1102, 2, x_1096);
+lean_ctor_set(x_1102, 3, x_1097);
+lean_ctor_set_uint8(x_1102, sizeof(void*)*4, x_1100);
+x_1103 = 0;
+lean_ctor_set(x_241, 3, x_1102);
+lean_ctor_set(x_241, 2, x_1088);
+lean_ctor_set(x_241, 1, x_1087);
+lean_ctor_set(x_241, 0, x_1101);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1103);
+return x_241;
 }
 }
 else
 {
-lean_object* x_1103; lean_object* x_1104; lean_object* x_1105; lean_object* x_1106; lean_object* x_1107; lean_object* x_1108; lean_object* x_1109; lean_object* x_1110; lean_object* x_1111; lean_object* x_1112; lean_object* x_1113; lean_object* x_1114; lean_object* x_1115; lean_object* x_1116; lean_object* x_1117; lean_object* x_1118; 
-x_1103 = lean_ctor_get(x_235, 0);
-x_1104 = lean_ctor_get(x_235, 1);
-x_1105 = lean_ctor_get(x_235, 2);
-x_1106 = lean_ctor_get(x_235, 3);
-lean_inc(x_1106);
-lean_inc(x_1105);
-lean_inc(x_1104);
-lean_inc(x_1103);
-lean_dec(x_235);
-x_1107 = lean_ctor_get(x_4, 1);
-lean_inc(x_1107);
-x_1108 = lean_ctor_get(x_4, 2);
-lean_inc(x_1108);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1109 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1109 = lean_box(0);
+uint8_t x_1104; 
+x_1104 = !lean_is_exclusive(x_4);
+if (x_1104 == 0)
+{
+lean_object* x_1105; lean_object* x_1106; uint8_t x_1107; 
+x_1105 = lean_ctor_get(x_4, 3);
+lean_dec(x_1105);
+x_1106 = lean_ctor_get(x_4, 0);
+lean_dec(x_1106);
+x_1107 = !lean_is_exclusive(x_973);
+if (x_1107 == 0)
+{
+lean_object* x_1108; lean_object* x_1109; lean_object* x_1110; lean_object* x_1111; uint8_t x_1112; uint8_t x_1113; 
+x_1108 = lean_ctor_get(x_973, 0);
+x_1109 = lean_ctor_get(x_973, 1);
+x_1110 = lean_ctor_get(x_973, 2);
+x_1111 = lean_ctor_get(x_973, 3);
+x_1112 = 1;
+lean_ctor_set(x_973, 3, x_1108);
+lean_ctor_set(x_973, 2, x_3);
+lean_ctor_set(x_973, 1, x_2);
+lean_ctor_set(x_973, 0, x_1);
+lean_ctor_set_uint8(x_973, sizeof(void*)*4, x_1112);
+lean_ctor_set(x_4, 0, x_1111);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1112);
+x_1113 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_1110);
+lean_ctor_set(x_241, 1, x_1109);
+lean_ctor_set(x_241, 0, x_973);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1113);
+return x_241;
 }
-x_1110 = lean_ctor_get(x_1020, 0);
-lean_inc(x_1110);
-x_1111 = lean_ctor_get(x_1020, 1);
-lean_inc(x_1111);
-x_1112 = lean_ctor_get(x_1020, 2);
-lean_inc(x_1112);
-x_1113 = lean_ctor_get(x_1020, 3);
-lean_inc(x_1113);
-if (lean_is_exclusive(x_1020)) {
- lean_ctor_release(x_1020, 0);
- lean_ctor_release(x_1020, 1);
- lean_ctor_release(x_1020, 2);
- lean_ctor_release(x_1020, 3);
- x_1114 = x_1020;
-} else {
- lean_dec_ref(x_1020);
- x_1114 = lean_box(0);
-}
-if (lean_is_scalar(x_1114)) {
- x_1115 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1115 = x_1114;
-}
-lean_ctor_set(x_1115, 0, x_1103);
-lean_ctor_set(x_1115, 1, x_1104);
-lean_ctor_set(x_1115, 2, x_1105);
-lean_ctor_set(x_1115, 3, x_1106);
-lean_ctor_set_uint8(x_1115, sizeof(void*)*4, x_806);
-if (lean_is_scalar(x_1109)) {
- x_1116 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1116 = x_1109;
-}
-lean_ctor_set(x_1116, 0, x_234);
-lean_ctor_set(x_1116, 1, x_1063);
-lean_ctor_set(x_1116, 2, x_1064);
-lean_ctor_set(x_1116, 3, x_1115);
-lean_ctor_set_uint8(x_1116, sizeof(void*)*4, x_1061);
-x_1117 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1117, 0, x_1116);
-lean_ctor_set(x_1117, 1, x_2);
-lean_ctor_set(x_1117, 2, x_3);
-lean_ctor_set(x_1117, 3, x_679);
-lean_ctor_set_uint8(x_1117, sizeof(void*)*4, x_806);
-lean_ctor_set(x_1, 3, x_1113);
-lean_ctor_set(x_1, 2, x_1112);
-lean_ctor_set(x_1, 1, x_1111);
-lean_ctor_set(x_1, 0, x_1110);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_806);
-x_1118 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1118, 0, x_1117);
-lean_ctor_set(x_1118, 1, x_1107);
-lean_ctor_set(x_1118, 2, x_1108);
-lean_ctor_set(x_1118, 3, x_1);
-lean_ctor_set_uint8(x_1118, sizeof(void*)*4, x_1061);
-return x_1118;
+else
+{
+lean_object* x_1114; lean_object* x_1115; lean_object* x_1116; lean_object* x_1117; uint8_t x_1118; lean_object* x_1119; uint8_t x_1120; 
+x_1114 = lean_ctor_get(x_973, 0);
+x_1115 = lean_ctor_get(x_973, 1);
+x_1116 = lean_ctor_get(x_973, 2);
+x_1117 = lean_ctor_get(x_973, 3);
+lean_inc(x_1117);
+lean_inc(x_1116);
+lean_inc(x_1115);
+lean_inc(x_1114);
+lean_dec(x_973);
+x_1118 = 1;
+x_1119 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1119, 0, x_1);
+lean_ctor_set(x_1119, 1, x_2);
+lean_ctor_set(x_1119, 2, x_3);
+lean_ctor_set(x_1119, 3, x_1114);
+lean_ctor_set_uint8(x_1119, sizeof(void*)*4, x_1118);
+lean_ctor_set(x_4, 0, x_1117);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1118);
+x_1120 = 0;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_1116);
+lean_ctor_set(x_241, 1, x_1115);
+lean_ctor_set(x_241, 0, x_1119);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1120);
+return x_241;
 }
 }
 else
 {
-lean_object* x_1119; lean_object* x_1120; lean_object* x_1121; lean_object* x_1122; lean_object* x_1123; lean_object* x_1124; lean_object* x_1125; lean_object* x_1126; lean_object* x_1127; lean_object* x_1128; lean_object* x_1129; lean_object* x_1130; lean_object* x_1131; lean_object* x_1132; lean_object* x_1133; lean_object* x_1134; lean_object* x_1135; lean_object* x_1136; lean_object* x_1137; lean_object* x_1138; 
-x_1119 = lean_ctor_get(x_1, 1);
-x_1120 = lean_ctor_get(x_1, 2);
-lean_inc(x_1120);
-lean_inc(x_1119);
-lean_dec(x_1);
-x_1121 = lean_ctor_get(x_235, 0);
-lean_inc(x_1121);
-x_1122 = lean_ctor_get(x_235, 1);
+lean_object* x_1121; lean_object* x_1122; lean_object* x_1123; lean_object* x_1124; lean_object* x_1125; lean_object* x_1126; lean_object* x_1127; uint8_t x_1128; lean_object* x_1129; lean_object* x_1130; uint8_t x_1131; 
+x_1121 = lean_ctor_get(x_4, 1);
+x_1122 = lean_ctor_get(x_4, 2);
 lean_inc(x_1122);
-x_1123 = lean_ctor_get(x_235, 2);
+lean_inc(x_1121);
+lean_dec(x_4);
+x_1123 = lean_ctor_get(x_973, 0);
 lean_inc(x_1123);
-x_1124 = lean_ctor_get(x_235, 3);
+x_1124 = lean_ctor_get(x_973, 1);
 lean_inc(x_1124);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_1125 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_1125 = lean_box(0);
-}
-x_1126 = lean_ctor_get(x_4, 1);
+x_1125 = lean_ctor_get(x_973, 2);
+lean_inc(x_1125);
+x_1126 = lean_ctor_get(x_973, 3);
 lean_inc(x_1126);
-x_1127 = lean_ctor_get(x_4, 2);
-lean_inc(x_1127);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1128 = x_4;
+if (lean_is_exclusive(x_973)) {
+ lean_ctor_release(x_973, 0);
+ lean_ctor_release(x_973, 1);
+ lean_ctor_release(x_973, 2);
+ lean_ctor_release(x_973, 3);
+ x_1127 = x_973;
 } else {
- lean_dec_ref(x_4);
- x_1128 = lean_box(0);
+ lean_dec_ref(x_973);
+ x_1127 = lean_box(0);
 }
-x_1129 = lean_ctor_get(x_1020, 0);
-lean_inc(x_1129);
-x_1130 = lean_ctor_get(x_1020, 1);
-lean_inc(x_1130);
-x_1131 = lean_ctor_get(x_1020, 2);
-lean_inc(x_1131);
-x_1132 = lean_ctor_get(x_1020, 3);
-lean_inc(x_1132);
-if (lean_is_exclusive(x_1020)) {
- lean_ctor_release(x_1020, 0);
- lean_ctor_release(x_1020, 1);
- lean_ctor_release(x_1020, 2);
- lean_ctor_release(x_1020, 3);
- x_1133 = x_1020;
+x_1128 = 1;
+if (lean_is_scalar(x_1127)) {
+ x_1129 = lean_alloc_ctor(1, 4, 1);
 } else {
- lean_dec_ref(x_1020);
- x_1133 = lean_box(0);
+ x_1129 = x_1127;
 }
-if (lean_is_scalar(x_1133)) {
- x_1134 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1134 = x_1133;
+lean_ctor_set(x_1129, 0, x_1);
+lean_ctor_set(x_1129, 1, x_2);
+lean_ctor_set(x_1129, 2, x_3);
+lean_ctor_set(x_1129, 3, x_1123);
+lean_ctor_set_uint8(x_1129, sizeof(void*)*4, x_1128);
+x_1130 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1130, 0, x_1126);
+lean_ctor_set(x_1130, 1, x_1121);
+lean_ctor_set(x_1130, 2, x_1122);
+lean_ctor_set(x_1130, 3, x_1016);
+lean_ctor_set_uint8(x_1130, sizeof(void*)*4, x_1128);
+x_1131 = 0;
+lean_ctor_set(x_241, 3, x_1130);
+lean_ctor_set(x_241, 2, x_1125);
+lean_ctor_set(x_241, 1, x_1124);
+lean_ctor_set(x_241, 0, x_1129);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1131);
+return x_241;
 }
-lean_ctor_set(x_1134, 0, x_1121);
-lean_ctor_set(x_1134, 1, x_1122);
-lean_ctor_set(x_1134, 2, x_1123);
-lean_ctor_set(x_1134, 3, x_1124);
-lean_ctor_set_uint8(x_1134, sizeof(void*)*4, x_806);
-if (lean_is_scalar(x_1128)) {
- x_1135 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1135 = x_1128;
 }
-lean_ctor_set(x_1135, 0, x_234);
-lean_ctor_set(x_1135, 1, x_1119);
-lean_ctor_set(x_1135, 2, x_1120);
-lean_ctor_set(x_1135, 3, x_1134);
-lean_ctor_set_uint8(x_1135, sizeof(void*)*4, x_1061);
-if (lean_is_scalar(x_1125)) {
- x_1136 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1136 = x_1125;
-}
-lean_ctor_set(x_1136, 0, x_1135);
-lean_ctor_set(x_1136, 1, x_2);
-lean_ctor_set(x_1136, 2, x_3);
-lean_ctor_set(x_1136, 3, x_679);
-lean_ctor_set_uint8(x_1136, sizeof(void*)*4, x_806);
-x_1137 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1137, 0, x_1129);
-lean_ctor_set(x_1137, 1, x_1130);
-lean_ctor_set(x_1137, 2, x_1131);
-lean_ctor_set(x_1137, 3, x_1132);
-lean_ctor_set_uint8(x_1137, sizeof(void*)*4, x_806);
-x_1138 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1138, 0, x_1136);
-lean_ctor_set(x_1138, 1, x_1126);
-lean_ctor_set(x_1138, 2, x_1127);
-lean_ctor_set(x_1138, 3, x_1137);
-lean_ctor_set_uint8(x_1138, sizeof(void*)*4, x_1061);
-return x_1138;
 }
 }
 else
 {
-uint8_t x_1139; 
-x_1139 = !lean_is_exclusive(x_1);
-if (x_1139 == 0)
+lean_object* x_1132; 
+lean_free_object(x_241);
+x_1132 = lean_ctor_get(x_4, 3);
+lean_inc(x_1132);
+if (lean_obj_tag(x_1132) == 0)
 {
-lean_object* x_1140; lean_object* x_1141; lean_object* x_1142; lean_object* x_1143; uint8_t x_1144; 
-x_1140 = lean_ctor_get(x_1, 1);
-x_1141 = lean_ctor_get(x_1, 2);
-x_1142 = lean_ctor_get(x_1, 3);
-lean_dec(x_1142);
-x_1143 = lean_ctor_get(x_1, 0);
+uint8_t x_1133; 
+x_1133 = !lean_is_exclusive(x_973);
+if (x_1133 == 0)
+{
+lean_object* x_1134; lean_object* x_1135; lean_object* x_1136; lean_object* x_1137; uint8_t x_1138; 
+x_1134 = lean_ctor_get(x_973, 3);
+lean_dec(x_1134);
+x_1135 = lean_ctor_get(x_973, 2);
+lean_dec(x_1135);
+x_1136 = lean_ctor_get(x_973, 1);
+lean_dec(x_1136);
+x_1137 = lean_ctor_get(x_973, 0);
+lean_dec(x_1137);
+x_1138 = 1;
+lean_ctor_set(x_973, 3, x_4);
+lean_ctor_set(x_973, 2, x_3);
+lean_ctor_set(x_973, 1, x_2);
+lean_ctor_set(x_973, 0, x_1);
+lean_ctor_set_uint8(x_973, sizeof(void*)*4, x_1138);
+return x_973;
+}
+else
+{
+uint8_t x_1139; lean_object* x_1140; 
+lean_dec(x_973);
+x_1139 = 1;
+x_1140 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1140, 0, x_1);
+lean_ctor_set(x_1140, 1, x_2);
+lean_ctor_set(x_1140, 2, x_3);
+lean_ctor_set(x_1140, 3, x_4);
+lean_ctor_set_uint8(x_1140, sizeof(void*)*4, x_1139);
+return x_1140;
+}
+}
+else
+{
+uint8_t x_1141; 
+x_1141 = lean_ctor_get_uint8(x_1132, sizeof(void*)*4);
+if (x_1141 == 0)
+{
+uint8_t x_1142; 
+x_1142 = !lean_is_exclusive(x_4);
+if (x_1142 == 0)
+{
+lean_object* x_1143; lean_object* x_1144; uint8_t x_1145; 
+x_1143 = lean_ctor_get(x_4, 3);
 lean_dec(x_1143);
-x_1144 = !lean_is_exclusive(x_235);
-if (x_1144 == 0)
-{
-uint8_t x_1145; 
-x_1145 = !lean_is_exclusive(x_4);
+x_1144 = lean_ctor_get(x_4, 0);
+lean_dec(x_1144);
+x_1145 = !lean_is_exclusive(x_1132);
 if (x_1145 == 0)
 {
-lean_object* x_1146; lean_object* x_1147; lean_object* x_1148; lean_object* x_1149; lean_object* x_1150; lean_object* x_1151; lean_object* x_1152; lean_object* x_1153; uint8_t x_1154; 
-x_1146 = lean_ctor_get(x_235, 0);
-x_1147 = lean_ctor_get(x_235, 1);
-x_1148 = lean_ctor_get(x_235, 2);
-x_1149 = lean_ctor_get(x_235, 3);
-x_1150 = lean_ctor_get(x_4, 1);
-x_1151 = lean_ctor_get(x_4, 2);
-x_1152 = lean_ctor_get(x_4, 3);
-lean_dec(x_1152);
-x_1153 = lean_ctor_get(x_4, 0);
-lean_dec(x_1153);
-x_1154 = !lean_is_exclusive(x_679);
-if (x_1154 == 0)
+lean_object* x_1146; lean_object* x_1147; lean_object* x_1148; lean_object* x_1149; uint8_t x_1150; uint8_t x_1151; 
+x_1146 = lean_ctor_get(x_1132, 0);
+x_1147 = lean_ctor_get(x_1132, 1);
+x_1148 = lean_ctor_get(x_1132, 2);
+x_1149 = lean_ctor_get(x_1132, 3);
+x_1150 = 1;
+lean_inc(x_973);
+lean_ctor_set(x_1132, 3, x_973);
+lean_ctor_set(x_1132, 2, x_3);
+lean_ctor_set(x_1132, 1, x_2);
+lean_ctor_set(x_1132, 0, x_1);
+x_1151 = !lean_is_exclusive(x_973);
+if (x_1151 == 0)
 {
-lean_object* x_1155; lean_object* x_1156; lean_object* x_1157; lean_object* x_1158; lean_object* x_1159; 
-x_1155 = lean_ctor_get(x_679, 0);
-x_1156 = lean_ctor_get(x_679, 1);
-x_1157 = lean_ctor_get(x_679, 2);
-x_1158 = lean_ctor_get(x_679, 3);
-lean_ctor_set(x_679, 3, x_1149);
-lean_ctor_set(x_679, 2, x_1148);
-lean_ctor_set(x_679, 1, x_1147);
-lean_ctor_set(x_679, 0, x_1146);
-lean_ctor_set_uint8(x_679, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_4, 3, x_679);
-lean_ctor_set(x_4, 2, x_1141);
-lean_ctor_set(x_4, 1, x_1140);
-lean_ctor_set(x_4, 0, x_234);
-lean_ctor_set(x_235, 3, x_1158);
-lean_ctor_set(x_235, 2, x_1157);
-lean_ctor_set(x_235, 1, x_1156);
-lean_ctor_set(x_235, 0, x_1155);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_1, 3, x_1020);
-lean_ctor_set(x_1, 2, x_1151);
-lean_ctor_set(x_1, 1, x_1150);
-lean_ctor_set(x_1, 0, x_235);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_678);
-x_1159 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1159, 0, x_4);
-lean_ctor_set(x_1159, 1, x_2);
-lean_ctor_set(x_1159, 2, x_3);
-lean_ctor_set(x_1159, 3, x_1);
-lean_ctor_set_uint8(x_1159, sizeof(void*)*4, x_1061);
-return x_1159;
+lean_object* x_1152; lean_object* x_1153; lean_object* x_1154; lean_object* x_1155; uint8_t x_1156; 
+x_1152 = lean_ctor_get(x_973, 3);
+lean_dec(x_1152);
+x_1153 = lean_ctor_get(x_973, 2);
+lean_dec(x_1153);
+x_1154 = lean_ctor_get(x_973, 1);
+lean_dec(x_1154);
+x_1155 = lean_ctor_get(x_973, 0);
+lean_dec(x_1155);
+lean_ctor_set_uint8(x_1132, sizeof(void*)*4, x_1150);
+lean_ctor_set(x_973, 3, x_1149);
+lean_ctor_set(x_973, 2, x_1148);
+lean_ctor_set(x_973, 1, x_1147);
+lean_ctor_set(x_973, 0, x_1146);
+lean_ctor_set_uint8(x_973, sizeof(void*)*4, x_1150);
+x_1156 = 0;
+lean_ctor_set(x_4, 3, x_973);
+lean_ctor_set(x_4, 0, x_1132);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1156);
+return x_4;
 }
 else
 {
-lean_object* x_1160; lean_object* x_1161; lean_object* x_1162; lean_object* x_1163; lean_object* x_1164; lean_object* x_1165; 
-x_1160 = lean_ctor_get(x_679, 0);
-x_1161 = lean_ctor_get(x_679, 1);
-x_1162 = lean_ctor_get(x_679, 2);
-x_1163 = lean_ctor_get(x_679, 3);
-lean_inc(x_1163);
+lean_object* x_1157; uint8_t x_1158; 
+lean_dec(x_973);
+lean_ctor_set_uint8(x_1132, sizeof(void*)*4, x_1150);
+x_1157 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1157, 0, x_1146);
+lean_ctor_set(x_1157, 1, x_1147);
+lean_ctor_set(x_1157, 2, x_1148);
+lean_ctor_set(x_1157, 3, x_1149);
+lean_ctor_set_uint8(x_1157, sizeof(void*)*4, x_1150);
+x_1158 = 0;
+lean_ctor_set(x_4, 3, x_1157);
+lean_ctor_set(x_4, 0, x_1132);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1158);
+return x_4;
+}
+}
+else
+{
+lean_object* x_1159; lean_object* x_1160; lean_object* x_1161; lean_object* x_1162; uint8_t x_1163; lean_object* x_1164; lean_object* x_1165; lean_object* x_1166; uint8_t x_1167; 
+x_1159 = lean_ctor_get(x_1132, 0);
+x_1160 = lean_ctor_get(x_1132, 1);
+x_1161 = lean_ctor_get(x_1132, 2);
+x_1162 = lean_ctor_get(x_1132, 3);
 lean_inc(x_1162);
 lean_inc(x_1161);
 lean_inc(x_1160);
-lean_dec(x_679);
+lean_inc(x_1159);
+lean_dec(x_1132);
+x_1163 = 1;
+lean_inc(x_973);
 x_1164 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1164, 0, x_1146);
-lean_ctor_set(x_1164, 1, x_1147);
-lean_ctor_set(x_1164, 2, x_1148);
-lean_ctor_set(x_1164, 3, x_1149);
-lean_ctor_set_uint8(x_1164, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_4, 3, x_1164);
-lean_ctor_set(x_4, 2, x_1141);
-lean_ctor_set(x_4, 1, x_1140);
-lean_ctor_set(x_4, 0, x_234);
-lean_ctor_set(x_235, 3, x_1163);
-lean_ctor_set(x_235, 2, x_1162);
-lean_ctor_set(x_235, 1, x_1161);
-lean_ctor_set(x_235, 0, x_1160);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_1, 3, x_1020);
-lean_ctor_set(x_1, 2, x_1151);
-lean_ctor_set(x_1, 1, x_1150);
-lean_ctor_set(x_1, 0, x_235);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_678);
-x_1165 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1165, 0, x_4);
-lean_ctor_set(x_1165, 1, x_2);
-lean_ctor_set(x_1165, 2, x_3);
-lean_ctor_set(x_1165, 3, x_1);
-lean_ctor_set_uint8(x_1165, sizeof(void*)*4, x_1061);
-return x_1165;
+lean_ctor_set(x_1164, 0, x_1);
+lean_ctor_set(x_1164, 1, x_2);
+lean_ctor_set(x_1164, 2, x_3);
+lean_ctor_set(x_1164, 3, x_973);
+if (lean_is_exclusive(x_973)) {
+ lean_ctor_release(x_973, 0);
+ lean_ctor_release(x_973, 1);
+ lean_ctor_release(x_973, 2);
+ lean_ctor_release(x_973, 3);
+ x_1165 = x_973;
+} else {
+ lean_dec_ref(x_973);
+ x_1165 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1164, sizeof(void*)*4, x_1163);
+if (lean_is_scalar(x_1165)) {
+ x_1166 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1166 = x_1165;
+}
+lean_ctor_set(x_1166, 0, x_1159);
+lean_ctor_set(x_1166, 1, x_1160);
+lean_ctor_set(x_1166, 2, x_1161);
+lean_ctor_set(x_1166, 3, x_1162);
+lean_ctor_set_uint8(x_1166, sizeof(void*)*4, x_1163);
+x_1167 = 0;
+lean_ctor_set(x_4, 3, x_1166);
+lean_ctor_set(x_4, 0, x_1164);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1167);
+return x_4;
 }
 }
 else
 {
-lean_object* x_1166; lean_object* x_1167; lean_object* x_1168; lean_object* x_1169; lean_object* x_1170; lean_object* x_1171; lean_object* x_1172; lean_object* x_1173; lean_object* x_1174; lean_object* x_1175; lean_object* x_1176; lean_object* x_1177; lean_object* x_1178; lean_object* x_1179; 
-x_1166 = lean_ctor_get(x_235, 0);
-x_1167 = lean_ctor_get(x_235, 1);
-x_1168 = lean_ctor_get(x_235, 2);
-x_1169 = lean_ctor_get(x_235, 3);
-x_1170 = lean_ctor_get(x_4, 1);
-x_1171 = lean_ctor_get(x_4, 2);
-lean_inc(x_1171);
-lean_inc(x_1170);
+lean_object* x_1168; lean_object* x_1169; lean_object* x_1170; lean_object* x_1171; lean_object* x_1172; lean_object* x_1173; lean_object* x_1174; uint8_t x_1175; lean_object* x_1176; lean_object* x_1177; lean_object* x_1178; uint8_t x_1179; lean_object* x_1180; 
+x_1168 = lean_ctor_get(x_4, 1);
+x_1169 = lean_ctor_get(x_4, 2);
+lean_inc(x_1169);
+lean_inc(x_1168);
 lean_dec(x_4);
-x_1172 = lean_ctor_get(x_679, 0);
+x_1170 = lean_ctor_get(x_1132, 0);
+lean_inc(x_1170);
+x_1171 = lean_ctor_get(x_1132, 1);
+lean_inc(x_1171);
+x_1172 = lean_ctor_get(x_1132, 2);
 lean_inc(x_1172);
-x_1173 = lean_ctor_get(x_679, 1);
+x_1173 = lean_ctor_get(x_1132, 3);
 lean_inc(x_1173);
-x_1174 = lean_ctor_get(x_679, 2);
-lean_inc(x_1174);
-x_1175 = lean_ctor_get(x_679, 3);
-lean_inc(x_1175);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_1176 = x_679;
+if (lean_is_exclusive(x_1132)) {
+ lean_ctor_release(x_1132, 0);
+ lean_ctor_release(x_1132, 1);
+ lean_ctor_release(x_1132, 2);
+ lean_ctor_release(x_1132, 3);
+ x_1174 = x_1132;
 } else {
- lean_dec_ref(x_679);
- x_1176 = lean_box(0);
+ lean_dec_ref(x_1132);
+ x_1174 = lean_box(0);
 }
-if (lean_is_scalar(x_1176)) {
- x_1177 = lean_alloc_ctor(1, 4, 1);
+x_1175 = 1;
+lean_inc(x_973);
+if (lean_is_scalar(x_1174)) {
+ x_1176 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1177 = x_1176;
+ x_1176 = x_1174;
 }
-lean_ctor_set(x_1177, 0, x_1166);
-lean_ctor_set(x_1177, 1, x_1167);
-lean_ctor_set(x_1177, 2, x_1168);
-lean_ctor_set(x_1177, 3, x_1169);
-lean_ctor_set_uint8(x_1177, sizeof(void*)*4, x_1061);
-x_1178 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1178, 0, x_234);
-lean_ctor_set(x_1178, 1, x_1140);
-lean_ctor_set(x_1178, 2, x_1141);
-lean_ctor_set(x_1178, 3, x_1177);
-lean_ctor_set_uint8(x_1178, sizeof(void*)*4, x_678);
-lean_ctor_set(x_235, 3, x_1175);
-lean_ctor_set(x_235, 2, x_1174);
-lean_ctor_set(x_235, 1, x_1173);
-lean_ctor_set(x_235, 0, x_1172);
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_1, 3, x_1020);
-lean_ctor_set(x_1, 2, x_1171);
-lean_ctor_set(x_1, 1, x_1170);
-lean_ctor_set(x_1, 0, x_235);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_678);
-x_1179 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1179, 0, x_1178);
-lean_ctor_set(x_1179, 1, x_2);
-lean_ctor_set(x_1179, 2, x_3);
-lean_ctor_set(x_1179, 3, x_1);
-lean_ctor_set_uint8(x_1179, sizeof(void*)*4, x_1061);
-return x_1179;
+lean_ctor_set(x_1176, 0, x_1);
+lean_ctor_set(x_1176, 1, x_2);
+lean_ctor_set(x_1176, 2, x_3);
+lean_ctor_set(x_1176, 3, x_973);
+if (lean_is_exclusive(x_973)) {
+ lean_ctor_release(x_973, 0);
+ lean_ctor_release(x_973, 1);
+ lean_ctor_release(x_973, 2);
+ lean_ctor_release(x_973, 3);
+ x_1177 = x_973;
+} else {
+ lean_dec_ref(x_973);
+ x_1177 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1176, sizeof(void*)*4, x_1175);
+if (lean_is_scalar(x_1177)) {
+ x_1178 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1178 = x_1177;
+}
+lean_ctor_set(x_1178, 0, x_1170);
+lean_ctor_set(x_1178, 1, x_1171);
+lean_ctor_set(x_1178, 2, x_1172);
+lean_ctor_set(x_1178, 3, x_1173);
+lean_ctor_set_uint8(x_1178, sizeof(void*)*4, x_1175);
+x_1179 = 0;
+x_1180 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1180, 0, x_1176);
+lean_ctor_set(x_1180, 1, x_1168);
+lean_ctor_set(x_1180, 2, x_1169);
+lean_ctor_set(x_1180, 3, x_1178);
+lean_ctor_set_uint8(x_1180, sizeof(void*)*4, x_1179);
+return x_1180;
 }
 }
 else
 {
-lean_object* x_1180; lean_object* x_1181; lean_object* x_1182; lean_object* x_1183; lean_object* x_1184; lean_object* x_1185; lean_object* x_1186; lean_object* x_1187; lean_object* x_1188; lean_object* x_1189; lean_object* x_1190; lean_object* x_1191; lean_object* x_1192; lean_object* x_1193; lean_object* x_1194; lean_object* x_1195; 
-x_1180 = lean_ctor_get(x_235, 0);
-x_1181 = lean_ctor_get(x_235, 1);
-x_1182 = lean_ctor_get(x_235, 2);
-x_1183 = lean_ctor_get(x_235, 3);
-lean_inc(x_1183);
-lean_inc(x_1182);
-lean_inc(x_1181);
-lean_inc(x_1180);
-lean_dec(x_235);
-x_1184 = lean_ctor_get(x_4, 1);
-lean_inc(x_1184);
-x_1185 = lean_ctor_get(x_4, 2);
-lean_inc(x_1185);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1186 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1186 = lean_box(0);
-}
-x_1187 = lean_ctor_get(x_679, 0);
-lean_inc(x_1187);
-x_1188 = lean_ctor_get(x_679, 1);
-lean_inc(x_1188);
-x_1189 = lean_ctor_get(x_679, 2);
-lean_inc(x_1189);
-x_1190 = lean_ctor_get(x_679, 3);
-lean_inc(x_1190);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_1191 = x_679;
-} else {
- lean_dec_ref(x_679);
- x_1191 = lean_box(0);
-}
-if (lean_is_scalar(x_1191)) {
- x_1192 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1192 = x_1191;
-}
-lean_ctor_set(x_1192, 0, x_1180);
-lean_ctor_set(x_1192, 1, x_1181);
-lean_ctor_set(x_1192, 2, x_1182);
-lean_ctor_set(x_1192, 3, x_1183);
-lean_ctor_set_uint8(x_1192, sizeof(void*)*4, x_1061);
-if (lean_is_scalar(x_1186)) {
- x_1193 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1193 = x_1186;
-}
-lean_ctor_set(x_1193, 0, x_234);
-lean_ctor_set(x_1193, 1, x_1140);
-lean_ctor_set(x_1193, 2, x_1141);
-lean_ctor_set(x_1193, 3, x_1192);
-lean_ctor_set_uint8(x_1193, sizeof(void*)*4, x_678);
-x_1194 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1194, 0, x_1187);
-lean_ctor_set(x_1194, 1, x_1188);
-lean_ctor_set(x_1194, 2, x_1189);
-lean_ctor_set(x_1194, 3, x_1190);
-lean_ctor_set_uint8(x_1194, sizeof(void*)*4, x_1061);
-lean_ctor_set(x_1, 3, x_1020);
-lean_ctor_set(x_1, 2, x_1185);
-lean_ctor_set(x_1, 1, x_1184);
-lean_ctor_set(x_1, 0, x_1194);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_678);
-x_1195 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1195, 0, x_1193);
-lean_ctor_set(x_1195, 1, x_2);
-lean_ctor_set(x_1195, 2, x_3);
-lean_ctor_set(x_1195, 3, x_1);
-lean_ctor_set_uint8(x_1195, sizeof(void*)*4, x_1061);
-return x_1195;
-}
+uint8_t x_1181; 
+lean_dec(x_973);
+x_1181 = !lean_is_exclusive(x_1132);
+if (x_1181 == 0)
+{
+lean_object* x_1182; lean_object* x_1183; lean_object* x_1184; lean_object* x_1185; uint8_t x_1186; 
+x_1182 = lean_ctor_get(x_1132, 3);
+lean_dec(x_1182);
+x_1183 = lean_ctor_get(x_1132, 2);
+lean_dec(x_1183);
+x_1184 = lean_ctor_get(x_1132, 1);
+lean_dec(x_1184);
+x_1185 = lean_ctor_get(x_1132, 0);
+lean_dec(x_1185);
+x_1186 = 1;
+lean_ctor_set(x_1132, 3, x_4);
+lean_ctor_set(x_1132, 2, x_3);
+lean_ctor_set(x_1132, 1, x_2);
+lean_ctor_set(x_1132, 0, x_1);
+lean_ctor_set_uint8(x_1132, sizeof(void*)*4, x_1186);
+return x_1132;
 }
 else
 {
-lean_object* x_1196; lean_object* x_1197; lean_object* x_1198; lean_object* x_1199; lean_object* x_1200; lean_object* x_1201; lean_object* x_1202; lean_object* x_1203; lean_object* x_1204; lean_object* x_1205; lean_object* x_1206; lean_object* x_1207; lean_object* x_1208; lean_object* x_1209; lean_object* x_1210; lean_object* x_1211; lean_object* x_1212; lean_object* x_1213; lean_object* x_1214; lean_object* x_1215; 
-x_1196 = lean_ctor_get(x_1, 1);
-x_1197 = lean_ctor_get(x_1, 2);
-lean_inc(x_1197);
-lean_inc(x_1196);
-lean_dec(x_1);
-x_1198 = lean_ctor_get(x_235, 0);
-lean_inc(x_1198);
-x_1199 = lean_ctor_get(x_235, 1);
-lean_inc(x_1199);
-x_1200 = lean_ctor_get(x_235, 2);
-lean_inc(x_1200);
-x_1201 = lean_ctor_get(x_235, 3);
-lean_inc(x_1201);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_1202 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_1202 = lean_box(0);
-}
-x_1203 = lean_ctor_get(x_4, 1);
-lean_inc(x_1203);
-x_1204 = lean_ctor_get(x_4, 2);
-lean_inc(x_1204);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1205 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1205 = lean_box(0);
-}
-x_1206 = lean_ctor_get(x_679, 0);
-lean_inc(x_1206);
-x_1207 = lean_ctor_get(x_679, 1);
-lean_inc(x_1207);
-x_1208 = lean_ctor_get(x_679, 2);
-lean_inc(x_1208);
-x_1209 = lean_ctor_get(x_679, 3);
-lean_inc(x_1209);
-if (lean_is_exclusive(x_679)) {
- lean_ctor_release(x_679, 0);
- lean_ctor_release(x_679, 1);
- lean_ctor_release(x_679, 2);
- lean_ctor_release(x_679, 3);
- x_1210 = x_679;
-} else {
- lean_dec_ref(x_679);
- x_1210 = lean_box(0);
-}
-if (lean_is_scalar(x_1210)) {
- x_1211 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1211 = x_1210;
-}
-lean_ctor_set(x_1211, 0, x_1198);
-lean_ctor_set(x_1211, 1, x_1199);
-lean_ctor_set(x_1211, 2, x_1200);
-lean_ctor_set(x_1211, 3, x_1201);
-lean_ctor_set_uint8(x_1211, sizeof(void*)*4, x_1061);
-if (lean_is_scalar(x_1205)) {
- x_1212 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1212 = x_1205;
-}
-lean_ctor_set(x_1212, 0, x_234);
-lean_ctor_set(x_1212, 1, x_1196);
-lean_ctor_set(x_1212, 2, x_1197);
-lean_ctor_set(x_1212, 3, x_1211);
-lean_ctor_set_uint8(x_1212, sizeof(void*)*4, x_678);
-if (lean_is_scalar(x_1202)) {
- x_1213 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1213 = x_1202;
-}
-lean_ctor_set(x_1213, 0, x_1206);
-lean_ctor_set(x_1213, 1, x_1207);
-lean_ctor_set(x_1213, 2, x_1208);
-lean_ctor_set(x_1213, 3, x_1209);
-lean_ctor_set_uint8(x_1213, sizeof(void*)*4, x_1061);
-x_1214 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1214, 0, x_1213);
-lean_ctor_set(x_1214, 1, x_1203);
-lean_ctor_set(x_1214, 2, x_1204);
-lean_ctor_set(x_1214, 3, x_1020);
-lean_ctor_set_uint8(x_1214, sizeof(void*)*4, x_678);
-x_1215 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1215, 0, x_1212);
-lean_ctor_set(x_1215, 1, x_2);
-lean_ctor_set(x_1215, 2, x_3);
-lean_ctor_set(x_1215, 3, x_1214);
-lean_ctor_set_uint8(x_1215, sizeof(void*)*4, x_1061);
-return x_1215;
+uint8_t x_1187; lean_object* x_1188; 
+lean_dec(x_1132);
+x_1187 = 1;
+x_1188 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1188, 0, x_1);
+lean_ctor_set(x_1188, 1, x_2);
+lean_ctor_set(x_1188, 2, x_3);
+lean_ctor_set(x_1188, 3, x_4);
+lean_ctor_set_uint8(x_1188, sizeof(void*)*4, x_1187);
+return x_1188;
 }
 }
 }
@@ -10833,2472 +11881,2492 @@ return x_1215;
 }
 else
 {
-uint8_t x_1216; 
-x_1216 = !lean_is_exclusive(x_1);
-if (x_1216 == 0)
-{
-lean_object* x_1217; lean_object* x_1218; uint8_t x_1219; 
-x_1217 = lean_ctor_get(x_1, 3);
-lean_dec(x_1217);
-x_1218 = lean_ctor_get(x_1, 0);
-lean_dec(x_1218);
-x_1219 = !lean_is_exclusive(x_235);
-if (x_1219 == 0)
-{
-lean_object* x_1220; 
-lean_ctor_set_uint8(x_235, sizeof(void*)*4, x_678);
-x_1220 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1220, 0, x_1);
-lean_ctor_set(x_1220, 1, x_2);
-lean_ctor_set(x_1220, 2, x_3);
-lean_ctor_set(x_1220, 3, x_4);
-lean_ctor_set_uint8(x_1220, sizeof(void*)*4, x_678);
-return x_1220;
-}
-else
-{
-lean_object* x_1221; lean_object* x_1222; lean_object* x_1223; lean_object* x_1224; lean_object* x_1225; lean_object* x_1226; 
-x_1221 = lean_ctor_get(x_235, 0);
-x_1222 = lean_ctor_get(x_235, 1);
-x_1223 = lean_ctor_get(x_235, 2);
-x_1224 = lean_ctor_get(x_235, 3);
-lean_inc(x_1224);
-lean_inc(x_1223);
-lean_inc(x_1222);
-lean_inc(x_1221);
-lean_dec(x_235);
-x_1225 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1225, 0, x_1221);
-lean_ctor_set(x_1225, 1, x_1222);
-lean_ctor_set(x_1225, 2, x_1223);
-lean_ctor_set(x_1225, 3, x_1224);
-lean_ctor_set_uint8(x_1225, sizeof(void*)*4, x_678);
-lean_ctor_set(x_1, 3, x_1225);
-x_1226 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1226, 0, x_1);
-lean_ctor_set(x_1226, 1, x_2);
-lean_ctor_set(x_1226, 2, x_3);
-lean_ctor_set(x_1226, 3, x_4);
-lean_ctor_set_uint8(x_1226, sizeof(void*)*4, x_678);
-return x_1226;
-}
-}
-else
-{
-lean_object* x_1227; lean_object* x_1228; lean_object* x_1229; lean_object* x_1230; lean_object* x_1231; lean_object* x_1232; lean_object* x_1233; lean_object* x_1234; lean_object* x_1235; lean_object* x_1236; 
-x_1227 = lean_ctor_get(x_1, 1);
-x_1228 = lean_ctor_get(x_1, 2);
-lean_inc(x_1228);
-lean_inc(x_1227);
-lean_dec(x_1);
-x_1229 = lean_ctor_get(x_235, 0);
-lean_inc(x_1229);
-x_1230 = lean_ctor_get(x_235, 1);
-lean_inc(x_1230);
-x_1231 = lean_ctor_get(x_235, 2);
-lean_inc(x_1231);
-x_1232 = lean_ctor_get(x_235, 3);
-lean_inc(x_1232);
-if (lean_is_exclusive(x_235)) {
- lean_ctor_release(x_235, 0);
- lean_ctor_release(x_235, 1);
- lean_ctor_release(x_235, 2);
- lean_ctor_release(x_235, 3);
- x_1233 = x_235;
-} else {
- lean_dec_ref(x_235);
- x_1233 = lean_box(0);
-}
-if (lean_is_scalar(x_1233)) {
- x_1234 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1234 = x_1233;
-}
-lean_ctor_set(x_1234, 0, x_1229);
-lean_ctor_set(x_1234, 1, x_1230);
-lean_ctor_set(x_1234, 2, x_1231);
-lean_ctor_set(x_1234, 3, x_1232);
-lean_ctor_set_uint8(x_1234, sizeof(void*)*4, x_678);
-x_1235 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1235, 0, x_234);
-lean_ctor_set(x_1235, 1, x_1227);
-lean_ctor_set(x_1235, 2, x_1228);
-lean_ctor_set(x_1235, 3, x_1234);
-lean_ctor_set_uint8(x_1235, sizeof(void*)*4, x_233);
-x_1236 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1236, 0, x_1235);
-lean_ctor_set(x_1236, 1, x_2);
-lean_ctor_set(x_1236, 2, x_3);
-lean_ctor_set(x_1236, 3, x_4);
-lean_ctor_set_uint8(x_1236, sizeof(void*)*4, x_678);
-return x_1236;
-}
-}
-}
+uint8_t x_1189; 
+x_1189 = 1;
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_3);
+lean_ctor_set(x_241, 1, x_2);
+lean_ctor_set(x_241, 0, x_1);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1189);
+return x_241;
 }
 }
 }
 else
 {
-uint8_t x_1237; 
-x_1237 = lean_ctor_get_uint8(x_234, sizeof(void*)*4);
-if (x_1237 == 0)
-{
-uint8_t x_1238; 
-x_1238 = !lean_is_exclusive(x_1);
-if (x_1238 == 0)
-{
-lean_object* x_1239; lean_object* x_1240; lean_object* x_1241; lean_object* x_1242; uint8_t x_1243; 
-x_1239 = lean_ctor_get(x_1, 1);
-x_1240 = lean_ctor_get(x_1, 2);
-x_1241 = lean_ctor_get(x_1, 3);
-x_1242 = lean_ctor_get(x_1, 0);
-lean_dec(x_1242);
-x_1243 = !lean_is_exclusive(x_234);
-if (x_1243 == 0)
-{
-uint8_t x_1244; lean_object* x_1245; 
-x_1244 = 1;
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1244);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_1241);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1244);
-x_1245 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1245, 0, x_234);
-lean_ctor_set(x_1245, 1, x_1239);
-lean_ctor_set(x_1245, 2, x_1240);
-lean_ctor_set(x_1245, 3, x_1);
-lean_ctor_set_uint8(x_1245, sizeof(void*)*4, x_1237);
-return x_1245;
-}
-else
-{
-lean_object* x_1246; lean_object* x_1247; lean_object* x_1248; lean_object* x_1249; uint8_t x_1250; lean_object* x_1251; lean_object* x_1252; 
-x_1246 = lean_ctor_get(x_234, 0);
-x_1247 = lean_ctor_get(x_234, 1);
-x_1248 = lean_ctor_get(x_234, 2);
-x_1249 = lean_ctor_get(x_234, 3);
-lean_inc(x_1249);
-lean_inc(x_1248);
-lean_inc(x_1247);
-lean_inc(x_1246);
-lean_dec(x_234);
-x_1250 = 1;
-x_1251 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1251, 0, x_1246);
-lean_ctor_set(x_1251, 1, x_1247);
-lean_ctor_set(x_1251, 2, x_1248);
-lean_ctor_set(x_1251, 3, x_1249);
-lean_ctor_set_uint8(x_1251, sizeof(void*)*4, x_1250);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_1241);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1250);
-x_1252 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1252, 0, x_1251);
-lean_ctor_set(x_1252, 1, x_1239);
-lean_ctor_set(x_1252, 2, x_1240);
-lean_ctor_set(x_1252, 3, x_1);
-lean_ctor_set_uint8(x_1252, sizeof(void*)*4, x_1237);
-return x_1252;
-}
-}
-else
-{
-lean_object* x_1253; lean_object* x_1254; lean_object* x_1255; lean_object* x_1256; lean_object* x_1257; lean_object* x_1258; lean_object* x_1259; lean_object* x_1260; uint8_t x_1261; lean_object* x_1262; lean_object* x_1263; lean_object* x_1264; 
-x_1253 = lean_ctor_get(x_1, 1);
-x_1254 = lean_ctor_get(x_1, 2);
-x_1255 = lean_ctor_get(x_1, 3);
-lean_inc(x_1255);
-lean_inc(x_1254);
-lean_inc(x_1253);
-lean_dec(x_1);
-x_1256 = lean_ctor_get(x_234, 0);
-lean_inc(x_1256);
-x_1257 = lean_ctor_get(x_234, 1);
-lean_inc(x_1257);
-x_1258 = lean_ctor_get(x_234, 2);
-lean_inc(x_1258);
-x_1259 = lean_ctor_get(x_234, 3);
-lean_inc(x_1259);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1260 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1260 = lean_box(0);
-}
-x_1261 = 1;
-if (lean_is_scalar(x_1260)) {
- x_1262 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1262 = x_1260;
-}
-lean_ctor_set(x_1262, 0, x_1256);
-lean_ctor_set(x_1262, 1, x_1257);
-lean_ctor_set(x_1262, 2, x_1258);
-lean_ctor_set(x_1262, 3, x_1259);
-lean_ctor_set_uint8(x_1262, sizeof(void*)*4, x_1261);
-x_1263 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1263, 0, x_1255);
-lean_ctor_set(x_1263, 1, x_2);
-lean_ctor_set(x_1263, 2, x_3);
-lean_ctor_set(x_1263, 3, x_4);
-lean_ctor_set_uint8(x_1263, sizeof(void*)*4, x_1261);
-x_1264 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1264, 0, x_1262);
-lean_ctor_set(x_1264, 1, x_1253);
-lean_ctor_set(x_1264, 2, x_1254);
-lean_ctor_set(x_1264, 3, x_1263);
-lean_ctor_set_uint8(x_1264, sizeof(void*)*4, x_1237);
-return x_1264;
-}
-}
-else
-{
-lean_object* x_1265; 
-x_1265 = lean_ctor_get(x_1, 3);
-lean_inc(x_1265);
-if (lean_obj_tag(x_1265) == 0)
-{
+lean_dec(x_241);
 if (lean_obj_tag(x_4) == 0)
 {
+uint8_t x_1190; lean_object* x_1191; 
+x_1190 = 1;
+x_1191 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1191, 0, x_1);
+lean_ctor_set(x_1191, 1, x_2);
+lean_ctor_set(x_1191, 2, x_3);
+lean_ctor_set(x_1191, 3, x_4);
+lean_ctor_set_uint8(x_1191, sizeof(void*)*4, x_1190);
+return x_1191;
+}
+else
+{
+uint8_t x_1192; 
+x_1192 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_1192 == 0)
+{
+lean_object* x_1193; 
+x_1193 = lean_ctor_get(x_4, 0);
+lean_inc(x_1193);
+if (lean_obj_tag(x_1193) == 0)
+{
+lean_object* x_1194; 
+x_1194 = lean_ctor_get(x_4, 3);
+lean_inc(x_1194);
+if (lean_obj_tag(x_1194) == 0)
+{
+uint8_t x_1195; lean_object* x_1196; 
+x_1195 = 1;
+x_1196 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1196, 0, x_1);
+lean_ctor_set(x_1196, 1, x_2);
+lean_ctor_set(x_1196, 2, x_3);
+lean_ctor_set(x_1196, 3, x_4);
+lean_ctor_set_uint8(x_1196, sizeof(void*)*4, x_1195);
+return x_1196;
+}
+else
+{
+uint8_t x_1197; 
+x_1197 = lean_ctor_get_uint8(x_1194, sizeof(void*)*4);
+if (x_1197 == 0)
+{
+lean_object* x_1198; lean_object* x_1199; lean_object* x_1200; lean_object* x_1201; lean_object* x_1202; lean_object* x_1203; lean_object* x_1204; lean_object* x_1205; uint8_t x_1206; lean_object* x_1207; lean_object* x_1208; uint8_t x_1209; lean_object* x_1210; 
+x_1198 = lean_ctor_get(x_4, 1);
+lean_inc(x_1198);
+x_1199 = lean_ctor_get(x_4, 2);
+lean_inc(x_1199);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1200 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1200 = lean_box(0);
+}
+x_1201 = lean_ctor_get(x_1194, 0);
+lean_inc(x_1201);
+x_1202 = lean_ctor_get(x_1194, 1);
+lean_inc(x_1202);
+x_1203 = lean_ctor_get(x_1194, 2);
+lean_inc(x_1203);
+x_1204 = lean_ctor_get(x_1194, 3);
+lean_inc(x_1204);
+if (lean_is_exclusive(x_1194)) {
+ lean_ctor_release(x_1194, 0);
+ lean_ctor_release(x_1194, 1);
+ lean_ctor_release(x_1194, 2);
+ lean_ctor_release(x_1194, 3);
+ x_1205 = x_1194;
+} else {
+ lean_dec_ref(x_1194);
+ x_1205 = lean_box(0);
+}
+x_1206 = 1;
+if (lean_is_scalar(x_1205)) {
+ x_1207 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1207 = x_1205;
+}
+lean_ctor_set(x_1207, 0, x_1);
+lean_ctor_set(x_1207, 1, x_2);
+lean_ctor_set(x_1207, 2, x_3);
+lean_ctor_set(x_1207, 3, x_1193);
+lean_ctor_set_uint8(x_1207, sizeof(void*)*4, x_1206);
+if (lean_is_scalar(x_1200)) {
+ x_1208 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1208 = x_1200;
+}
+lean_ctor_set(x_1208, 0, x_1201);
+lean_ctor_set(x_1208, 1, x_1202);
+lean_ctor_set(x_1208, 2, x_1203);
+lean_ctor_set(x_1208, 3, x_1204);
+lean_ctor_set_uint8(x_1208, sizeof(void*)*4, x_1206);
+x_1209 = 0;
+x_1210 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1210, 0, x_1207);
+lean_ctor_set(x_1210, 1, x_1198);
+lean_ctor_set(x_1210, 2, x_1199);
+lean_ctor_set(x_1210, 3, x_1208);
+lean_ctor_set_uint8(x_1210, sizeof(void*)*4, x_1209);
+return x_1210;
+}
+else
+{
+lean_object* x_1211; uint8_t x_1212; lean_object* x_1213; 
+if (lean_is_exclusive(x_1194)) {
+ lean_ctor_release(x_1194, 0);
+ lean_ctor_release(x_1194, 1);
+ lean_ctor_release(x_1194, 2);
+ lean_ctor_release(x_1194, 3);
+ x_1211 = x_1194;
+} else {
+ lean_dec_ref(x_1194);
+ x_1211 = lean_box(0);
+}
+x_1212 = 1;
+if (lean_is_scalar(x_1211)) {
+ x_1213 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1213 = x_1211;
+}
+lean_ctor_set(x_1213, 0, x_1);
+lean_ctor_set(x_1213, 1, x_2);
+lean_ctor_set(x_1213, 2, x_3);
+lean_ctor_set(x_1213, 3, x_4);
+lean_ctor_set_uint8(x_1213, sizeof(void*)*4, x_1212);
+return x_1213;
+}
+}
+}
+else
+{
+uint8_t x_1214; 
+x_1214 = lean_ctor_get_uint8(x_1193, sizeof(void*)*4);
+if (x_1214 == 0)
+{
+lean_object* x_1215; 
+x_1215 = lean_ctor_get(x_4, 3);
+lean_inc(x_1215);
+if (lean_obj_tag(x_1215) == 0)
+{
+lean_object* x_1216; lean_object* x_1217; lean_object* x_1218; lean_object* x_1219; lean_object* x_1220; lean_object* x_1221; lean_object* x_1222; lean_object* x_1223; uint8_t x_1224; lean_object* x_1225; lean_object* x_1226; uint8_t x_1227; lean_object* x_1228; 
+x_1216 = lean_ctor_get(x_4, 1);
+lean_inc(x_1216);
+x_1217 = lean_ctor_get(x_4, 2);
+lean_inc(x_1217);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1218 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1218 = lean_box(0);
+}
+x_1219 = lean_ctor_get(x_1193, 0);
+lean_inc(x_1219);
+x_1220 = lean_ctor_get(x_1193, 1);
+lean_inc(x_1220);
+x_1221 = lean_ctor_get(x_1193, 2);
+lean_inc(x_1221);
+x_1222 = lean_ctor_get(x_1193, 3);
+lean_inc(x_1222);
+if (lean_is_exclusive(x_1193)) {
+ lean_ctor_release(x_1193, 0);
+ lean_ctor_release(x_1193, 1);
+ lean_ctor_release(x_1193, 2);
+ lean_ctor_release(x_1193, 3);
+ x_1223 = x_1193;
+} else {
+ lean_dec_ref(x_1193);
+ x_1223 = lean_box(0);
+}
+x_1224 = 1;
+if (lean_is_scalar(x_1223)) {
+ x_1225 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1225 = x_1223;
+}
+lean_ctor_set(x_1225, 0, x_1);
+lean_ctor_set(x_1225, 1, x_2);
+lean_ctor_set(x_1225, 2, x_3);
+lean_ctor_set(x_1225, 3, x_1219);
+lean_ctor_set_uint8(x_1225, sizeof(void*)*4, x_1224);
+if (lean_is_scalar(x_1218)) {
+ x_1226 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1226 = x_1218;
+}
+lean_ctor_set(x_1226, 0, x_1222);
+lean_ctor_set(x_1226, 1, x_1216);
+lean_ctor_set(x_1226, 2, x_1217);
+lean_ctor_set(x_1226, 3, x_1215);
+lean_ctor_set_uint8(x_1226, sizeof(void*)*4, x_1224);
+x_1227 = 0;
+x_1228 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1228, 0, x_1225);
+lean_ctor_set(x_1228, 1, x_1220);
+lean_ctor_set(x_1228, 2, x_1221);
+lean_ctor_set(x_1228, 3, x_1226);
+lean_ctor_set_uint8(x_1228, sizeof(void*)*4, x_1227);
+return x_1228;
+}
+else
+{
+uint8_t x_1229; 
+x_1229 = lean_ctor_get_uint8(x_1215, sizeof(void*)*4);
+if (x_1229 == 0)
+{
+lean_object* x_1230; lean_object* x_1231; lean_object* x_1232; lean_object* x_1233; lean_object* x_1234; lean_object* x_1235; lean_object* x_1236; lean_object* x_1237; lean_object* x_1238; lean_object* x_1239; lean_object* x_1240; lean_object* x_1241; lean_object* x_1242; lean_object* x_1243; uint8_t x_1244; lean_object* x_1245; lean_object* x_1246; uint8_t x_1247; lean_object* x_1248; 
+x_1230 = lean_ctor_get(x_4, 1);
+lean_inc(x_1230);
+x_1231 = lean_ctor_get(x_4, 2);
+lean_inc(x_1231);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1232 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1232 = lean_box(0);
+}
+x_1233 = lean_ctor_get(x_1193, 0);
+lean_inc(x_1233);
+x_1234 = lean_ctor_get(x_1193, 1);
+lean_inc(x_1234);
+x_1235 = lean_ctor_get(x_1193, 2);
+lean_inc(x_1235);
+x_1236 = lean_ctor_get(x_1193, 3);
+lean_inc(x_1236);
+if (lean_is_exclusive(x_1193)) {
+ lean_ctor_release(x_1193, 0);
+ lean_ctor_release(x_1193, 1);
+ lean_ctor_release(x_1193, 2);
+ lean_ctor_release(x_1193, 3);
+ x_1237 = x_1193;
+} else {
+ lean_dec_ref(x_1193);
+ x_1237 = lean_box(0);
+}
+x_1238 = lean_ctor_get(x_1215, 0);
+lean_inc(x_1238);
+x_1239 = lean_ctor_get(x_1215, 1);
+lean_inc(x_1239);
+x_1240 = lean_ctor_get(x_1215, 2);
+lean_inc(x_1240);
+x_1241 = lean_ctor_get(x_1215, 3);
+lean_inc(x_1241);
+if (lean_is_exclusive(x_1215)) {
+ lean_ctor_release(x_1215, 0);
+ lean_ctor_release(x_1215, 1);
+ lean_ctor_release(x_1215, 2);
+ lean_ctor_release(x_1215, 3);
+ x_1242 = x_1215;
+} else {
+ lean_dec_ref(x_1215);
+ x_1242 = lean_box(0);
+}
+if (lean_is_scalar(x_1242)) {
+ x_1243 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1243 = x_1242;
+}
+lean_ctor_set(x_1243, 0, x_1233);
+lean_ctor_set(x_1243, 1, x_1234);
+lean_ctor_set(x_1243, 2, x_1235);
+lean_ctor_set(x_1243, 3, x_1236);
+lean_ctor_set_uint8(x_1243, sizeof(void*)*4, x_1229);
+x_1244 = 1;
+if (lean_is_scalar(x_1237)) {
+ x_1245 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1245 = x_1237;
+}
+lean_ctor_set(x_1245, 0, x_1);
+lean_ctor_set(x_1245, 1, x_2);
+lean_ctor_set(x_1245, 2, x_3);
+lean_ctor_set(x_1245, 3, x_1243);
+lean_ctor_set_uint8(x_1245, sizeof(void*)*4, x_1244);
+if (lean_is_scalar(x_1232)) {
+ x_1246 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1246 = x_1232;
+}
+lean_ctor_set(x_1246, 0, x_1238);
+lean_ctor_set(x_1246, 1, x_1239);
+lean_ctor_set(x_1246, 2, x_1240);
+lean_ctor_set(x_1246, 3, x_1241);
+lean_ctor_set_uint8(x_1246, sizeof(void*)*4, x_1244);
+x_1247 = 0;
+x_1248 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1248, 0, x_1245);
+lean_ctor_set(x_1248, 1, x_1230);
+lean_ctor_set(x_1248, 2, x_1231);
+lean_ctor_set(x_1248, 3, x_1246);
+lean_ctor_set_uint8(x_1248, sizeof(void*)*4, x_1247);
+return x_1248;
+}
+else
+{
+lean_object* x_1249; lean_object* x_1250; lean_object* x_1251; lean_object* x_1252; lean_object* x_1253; lean_object* x_1254; lean_object* x_1255; lean_object* x_1256; uint8_t x_1257; lean_object* x_1258; lean_object* x_1259; uint8_t x_1260; lean_object* x_1261; 
+x_1249 = lean_ctor_get(x_4, 1);
+lean_inc(x_1249);
+x_1250 = lean_ctor_get(x_4, 2);
+lean_inc(x_1250);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1251 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1251 = lean_box(0);
+}
+x_1252 = lean_ctor_get(x_1193, 0);
+lean_inc(x_1252);
+x_1253 = lean_ctor_get(x_1193, 1);
+lean_inc(x_1253);
+x_1254 = lean_ctor_get(x_1193, 2);
+lean_inc(x_1254);
+x_1255 = lean_ctor_get(x_1193, 3);
+lean_inc(x_1255);
+if (lean_is_exclusive(x_1193)) {
+ lean_ctor_release(x_1193, 0);
+ lean_ctor_release(x_1193, 1);
+ lean_ctor_release(x_1193, 2);
+ lean_ctor_release(x_1193, 3);
+ x_1256 = x_1193;
+} else {
+ lean_dec_ref(x_1193);
+ x_1256 = lean_box(0);
+}
+x_1257 = 1;
+if (lean_is_scalar(x_1256)) {
+ x_1258 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1258 = x_1256;
+}
+lean_ctor_set(x_1258, 0, x_1);
+lean_ctor_set(x_1258, 1, x_2);
+lean_ctor_set(x_1258, 2, x_3);
+lean_ctor_set(x_1258, 3, x_1252);
+lean_ctor_set_uint8(x_1258, sizeof(void*)*4, x_1257);
+if (lean_is_scalar(x_1251)) {
+ x_1259 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1259 = x_1251;
+}
+lean_ctor_set(x_1259, 0, x_1255);
+lean_ctor_set(x_1259, 1, x_1249);
+lean_ctor_set(x_1259, 2, x_1250);
+lean_ctor_set(x_1259, 3, x_1215);
+lean_ctor_set_uint8(x_1259, sizeof(void*)*4, x_1257);
+x_1260 = 0;
+x_1261 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1261, 0, x_1258);
+lean_ctor_set(x_1261, 1, x_1253);
+lean_ctor_set(x_1261, 2, x_1254);
+lean_ctor_set(x_1261, 3, x_1259);
+lean_ctor_set_uint8(x_1261, sizeof(void*)*4, x_1260);
+return x_1261;
+}
+}
+}
+else
+{
+lean_object* x_1262; 
+x_1262 = lean_ctor_get(x_4, 3);
+lean_inc(x_1262);
+if (lean_obj_tag(x_1262) == 0)
+{
+lean_object* x_1263; uint8_t x_1264; lean_object* x_1265; 
+if (lean_is_exclusive(x_1193)) {
+ lean_ctor_release(x_1193, 0);
+ lean_ctor_release(x_1193, 1);
+ lean_ctor_release(x_1193, 2);
+ lean_ctor_release(x_1193, 3);
+ x_1263 = x_1193;
+} else {
+ lean_dec_ref(x_1193);
+ x_1263 = lean_box(0);
+}
+x_1264 = 1;
+if (lean_is_scalar(x_1263)) {
+ x_1265 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1265 = x_1263;
+}
+lean_ctor_set(x_1265, 0, x_1);
+lean_ctor_set(x_1265, 1, x_2);
+lean_ctor_set(x_1265, 2, x_3);
+lean_ctor_set(x_1265, 3, x_4);
+lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1264);
+return x_1265;
+}
+else
+{
 uint8_t x_1266; 
-x_1266 = !lean_is_exclusive(x_1);
+x_1266 = lean_ctor_get_uint8(x_1262, sizeof(void*)*4);
 if (x_1266 == 0)
 {
-lean_object* x_1267; lean_object* x_1268; lean_object* x_1269; 
-x_1267 = lean_ctor_get(x_1, 3);
-lean_dec(x_1267);
-x_1268 = lean_ctor_get(x_1, 0);
-lean_dec(x_1268);
-lean_ctor_set(x_1, 3, x_4);
-x_1269 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1269, 0, x_1);
-lean_ctor_set(x_1269, 1, x_2);
-lean_ctor_set(x_1269, 2, x_3);
-lean_ctor_set(x_1269, 3, x_4);
-lean_ctor_set_uint8(x_1269, sizeof(void*)*4, x_1237);
-return x_1269;
+lean_object* x_1267; lean_object* x_1268; lean_object* x_1269; lean_object* x_1270; lean_object* x_1271; lean_object* x_1272; lean_object* x_1273; lean_object* x_1274; uint8_t x_1275; lean_object* x_1276; lean_object* x_1277; lean_object* x_1278; uint8_t x_1279; lean_object* x_1280; 
+x_1267 = lean_ctor_get(x_4, 1);
+lean_inc(x_1267);
+x_1268 = lean_ctor_get(x_4, 2);
+lean_inc(x_1268);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1269 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1269 = lean_box(0);
 }
-else
-{
-lean_object* x_1270; lean_object* x_1271; lean_object* x_1272; lean_object* x_1273; 
-x_1270 = lean_ctor_get(x_1, 1);
-x_1271 = lean_ctor_get(x_1, 2);
-lean_inc(x_1271);
+x_1270 = lean_ctor_get(x_1262, 0);
 lean_inc(x_1270);
-lean_dec(x_1);
-x_1272 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1272, 0, x_234);
-lean_ctor_set(x_1272, 1, x_1270);
-lean_ctor_set(x_1272, 2, x_1271);
-lean_ctor_set(x_1272, 3, x_4);
-lean_ctor_set_uint8(x_1272, sizeof(void*)*4, x_233);
-x_1273 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1273, 0, x_1272);
-lean_ctor_set(x_1273, 1, x_2);
-lean_ctor_set(x_1273, 2, x_3);
-lean_ctor_set(x_1273, 3, x_4);
-lean_ctor_set_uint8(x_1273, sizeof(void*)*4, x_1237);
-return x_1273;
+x_1271 = lean_ctor_get(x_1262, 1);
+lean_inc(x_1271);
+x_1272 = lean_ctor_get(x_1262, 2);
+lean_inc(x_1272);
+x_1273 = lean_ctor_get(x_1262, 3);
+lean_inc(x_1273);
+if (lean_is_exclusive(x_1262)) {
+ lean_ctor_release(x_1262, 0);
+ lean_ctor_release(x_1262, 1);
+ lean_ctor_release(x_1262, 2);
+ lean_ctor_release(x_1262, 3);
+ x_1274 = x_1262;
+} else {
+ lean_dec_ref(x_1262);
+ x_1274 = lean_box(0);
+}
+x_1275 = 1;
+lean_inc(x_1193);
+if (lean_is_scalar(x_1274)) {
+ x_1276 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1276 = x_1274;
+}
+lean_ctor_set(x_1276, 0, x_1);
+lean_ctor_set(x_1276, 1, x_2);
+lean_ctor_set(x_1276, 2, x_3);
+lean_ctor_set(x_1276, 3, x_1193);
+if (lean_is_exclusive(x_1193)) {
+ lean_ctor_release(x_1193, 0);
+ lean_ctor_release(x_1193, 1);
+ lean_ctor_release(x_1193, 2);
+ lean_ctor_release(x_1193, 3);
+ x_1277 = x_1193;
+} else {
+ lean_dec_ref(x_1193);
+ x_1277 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1276, sizeof(void*)*4, x_1275);
+if (lean_is_scalar(x_1277)) {
+ x_1278 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1278 = x_1277;
+}
+lean_ctor_set(x_1278, 0, x_1270);
+lean_ctor_set(x_1278, 1, x_1271);
+lean_ctor_set(x_1278, 2, x_1272);
+lean_ctor_set(x_1278, 3, x_1273);
+lean_ctor_set_uint8(x_1278, sizeof(void*)*4, x_1275);
+x_1279 = 0;
+if (lean_is_scalar(x_1269)) {
+ x_1280 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1280 = x_1269;
+}
+lean_ctor_set(x_1280, 0, x_1276);
+lean_ctor_set(x_1280, 1, x_1267);
+lean_ctor_set(x_1280, 2, x_1268);
+lean_ctor_set(x_1280, 3, x_1278);
+lean_ctor_set_uint8(x_1280, sizeof(void*)*4, x_1279);
+return x_1280;
+}
+else
+{
+lean_object* x_1281; uint8_t x_1282; lean_object* x_1283; 
+lean_dec(x_1193);
+if (lean_is_exclusive(x_1262)) {
+ lean_ctor_release(x_1262, 0);
+ lean_ctor_release(x_1262, 1);
+ lean_ctor_release(x_1262, 2);
+ lean_ctor_release(x_1262, 3);
+ x_1281 = x_1262;
+} else {
+ lean_dec_ref(x_1262);
+ x_1281 = lean_box(0);
+}
+x_1282 = 1;
+if (lean_is_scalar(x_1281)) {
+ x_1283 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1283 = x_1281;
+}
+lean_ctor_set(x_1283, 0, x_1);
+lean_ctor_set(x_1283, 1, x_2);
+lean_ctor_set(x_1283, 2, x_3);
+lean_ctor_set(x_1283, 3, x_4);
+lean_ctor_set_uint8(x_1283, sizeof(void*)*4, x_1282);
+return x_1283;
+}
+}
+}
 }
 }
 else
 {
-uint8_t x_1274; 
-x_1274 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
-if (x_1274 == 0)
+uint8_t x_1284; lean_object* x_1285; 
+x_1284 = 1;
+x_1285 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1285, 0, x_1);
+lean_ctor_set(x_1285, 1, x_2);
+lean_ctor_set(x_1285, 2, x_3);
+lean_ctor_set(x_1285, 3, x_4);
+lean_ctor_set_uint8(x_1285, sizeof(void*)*4, x_1284);
+return x_1285;
+}
+}
+}
+}
+else
 {
-lean_object* x_1275; 
-x_1275 = lean_ctor_get(x_4, 0);
-lean_inc(x_1275);
-if (lean_obj_tag(x_1275) == 0)
+uint8_t x_1286; 
+x_1286 = lean_ctor_get_uint8(x_965, sizeof(void*)*4);
+if (x_1286 == 0)
 {
-lean_object* x_1276; 
-x_1276 = lean_ctor_get(x_4, 3);
-lean_inc(x_1276);
-if (lean_obj_tag(x_1276) == 0)
-{
-uint8_t x_1277; 
-x_1277 = !lean_is_exclusive(x_1);
-if (x_1277 == 0)
-{
-lean_object* x_1278; lean_object* x_1279; lean_object* x_1280; lean_object* x_1281; uint8_t x_1282; 
-x_1278 = lean_ctor_get(x_1, 1);
-x_1279 = lean_ctor_get(x_1, 2);
-x_1280 = lean_ctor_get(x_1, 3);
-lean_dec(x_1280);
-x_1281 = lean_ctor_get(x_1, 0);
-lean_dec(x_1281);
-x_1282 = !lean_is_exclusive(x_4);
-if (x_1282 == 0)
-{
-lean_object* x_1283; lean_object* x_1284; lean_object* x_1285; lean_object* x_1286; uint8_t x_1287; 
-x_1283 = lean_ctor_get(x_4, 1);
-x_1284 = lean_ctor_get(x_4, 2);
-x_1285 = lean_ctor_get(x_4, 3);
-lean_dec(x_1285);
-x_1286 = lean_ctor_get(x_4, 0);
-lean_dec(x_1286);
-lean_inc(x_234);
-lean_ctor_set(x_4, 2, x_1279);
-lean_ctor_set(x_4, 1, x_1278);
-lean_ctor_set(x_4, 0, x_234);
-x_1287 = !lean_is_exclusive(x_234);
+uint8_t x_1287; 
+x_1287 = !lean_is_exclusive(x_1);
 if (x_1287 == 0)
 {
-lean_object* x_1288; lean_object* x_1289; lean_object* x_1290; lean_object* x_1291; 
-x_1288 = lean_ctor_get(x_234, 3);
-lean_dec(x_1288);
-x_1289 = lean_ctor_get(x_234, 2);
-lean_dec(x_1289);
-x_1290 = lean_ctor_get(x_234, 1);
+lean_object* x_1288; lean_object* x_1289; lean_object* x_1290; lean_object* x_1291; uint8_t x_1292; 
+x_1288 = lean_ctor_get(x_1, 1);
+x_1289 = lean_ctor_get(x_1, 2);
+x_1290 = lean_ctor_get(x_1, 3);
 lean_dec(x_1290);
-x_1291 = lean_ctor_get(x_234, 0);
+x_1291 = lean_ctor_get(x_1, 0);
 lean_dec(x_1291);
-lean_ctor_set(x_234, 3, x_1276);
-lean_ctor_set(x_234, 2, x_1284);
-lean_ctor_set(x_234, 1, x_1283);
-lean_ctor_set(x_234, 0, x_1276);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1237);
+x_1292 = !lean_is_exclusive(x_965);
+if (x_1292 == 0)
+{
+lean_object* x_1293; lean_object* x_1294; lean_object* x_1295; lean_object* x_1296; uint8_t x_1297; uint8_t x_1298; 
+x_1293 = lean_ctor_get(x_965, 0);
+x_1294 = lean_ctor_get(x_965, 1);
+x_1295 = lean_ctor_get(x_965, 2);
+x_1296 = lean_ctor_get(x_965, 3);
+x_1297 = 1;
+lean_inc(x_241);
+lean_ctor_set(x_965, 3, x_1293);
+lean_ctor_set(x_965, 2, x_1289);
+lean_ctor_set(x_965, 1, x_1288);
+lean_ctor_set(x_965, 0, x_241);
+x_1298 = !lean_is_exclusive(x_241);
+if (x_1298 == 0)
+{
+lean_object* x_1299; lean_object* x_1300; lean_object* x_1301; lean_object* x_1302; uint8_t x_1303; 
+x_1299 = lean_ctor_get(x_241, 3);
+lean_dec(x_1299);
+x_1300 = lean_ctor_get(x_241, 2);
+lean_dec(x_1300);
+x_1301 = lean_ctor_get(x_241, 1);
+lean_dec(x_1301);
+x_1302 = lean_ctor_get(x_241, 0);
+lean_dec(x_1302);
+lean_ctor_set_uint8(x_965, sizeof(void*)*4, x_1297);
+lean_ctor_set(x_241, 3, x_4);
+lean_ctor_set(x_241, 2, x_3);
+lean_ctor_set(x_241, 1, x_2);
+lean_ctor_set(x_241, 0, x_1296);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1297);
+x_1303 = 0;
+lean_ctor_set(x_1, 3, x_241);
+lean_ctor_set(x_1, 2, x_1295);
+lean_ctor_set(x_1, 1, x_1294);
+lean_ctor_set(x_1, 0, x_965);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1303);
 return x_1;
 }
 else
 {
-lean_object* x_1292; 
-lean_dec(x_234);
-x_1292 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1292, 0, x_1276);
-lean_ctor_set(x_1292, 1, x_1283);
-lean_ctor_set(x_1292, 2, x_1284);
-lean_ctor_set(x_1292, 3, x_1276);
-lean_ctor_set_uint8(x_1292, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 3, x_1292);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1237);
+lean_object* x_1304; uint8_t x_1305; 
+lean_dec(x_241);
+lean_ctor_set_uint8(x_965, sizeof(void*)*4, x_1297);
+x_1304 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1304, 0, x_1296);
+lean_ctor_set(x_1304, 1, x_2);
+lean_ctor_set(x_1304, 2, x_3);
+lean_ctor_set(x_1304, 3, x_4);
+lean_ctor_set_uint8(x_1304, sizeof(void*)*4, x_1297);
+x_1305 = 0;
+lean_ctor_set(x_1, 3, x_1304);
+lean_ctor_set(x_1, 2, x_1295);
+lean_ctor_set(x_1, 1, x_1294);
+lean_ctor_set(x_1, 0, x_965);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1305);
 return x_1;
 }
 }
 else
 {
-lean_object* x_1293; lean_object* x_1294; lean_object* x_1295; lean_object* x_1296; lean_object* x_1297; 
-x_1293 = lean_ctor_get(x_4, 1);
-x_1294 = lean_ctor_get(x_4, 2);
-lean_inc(x_1294);
-lean_inc(x_1293);
-lean_dec(x_4);
-lean_inc(x_234);
-x_1295 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1295, 0, x_234);
-lean_ctor_set(x_1295, 1, x_1278);
-lean_ctor_set(x_1295, 2, x_1279);
-lean_ctor_set(x_1295, 3, x_1276);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1296 = x_234;
+lean_object* x_1306; lean_object* x_1307; lean_object* x_1308; lean_object* x_1309; uint8_t x_1310; lean_object* x_1311; lean_object* x_1312; lean_object* x_1313; uint8_t x_1314; 
+x_1306 = lean_ctor_get(x_965, 0);
+x_1307 = lean_ctor_get(x_965, 1);
+x_1308 = lean_ctor_get(x_965, 2);
+x_1309 = lean_ctor_get(x_965, 3);
+lean_inc(x_1309);
+lean_inc(x_1308);
+lean_inc(x_1307);
+lean_inc(x_1306);
+lean_dec(x_965);
+x_1310 = 1;
+lean_inc(x_241);
+x_1311 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1311, 0, x_241);
+lean_ctor_set(x_1311, 1, x_1288);
+lean_ctor_set(x_1311, 2, x_1289);
+lean_ctor_set(x_1311, 3, x_1306);
+if (lean_is_exclusive(x_241)) {
+ lean_ctor_release(x_241, 0);
+ lean_ctor_release(x_241, 1);
+ lean_ctor_release(x_241, 2);
+ lean_ctor_release(x_241, 3);
+ x_1312 = x_241;
 } else {
- lean_dec_ref(x_234);
- x_1296 = lean_box(0);
+ lean_dec_ref(x_241);
+ x_1312 = lean_box(0);
 }
-lean_ctor_set_uint8(x_1295, sizeof(void*)*4, x_1274);
-if (lean_is_scalar(x_1296)) {
- x_1297 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set_uint8(x_1311, sizeof(void*)*4, x_1310);
+if (lean_is_scalar(x_1312)) {
+ x_1313 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1297 = x_1296;
+ x_1313 = x_1312;
 }
-lean_ctor_set(x_1297, 0, x_1276);
-lean_ctor_set(x_1297, 1, x_1293);
-lean_ctor_set(x_1297, 2, x_1294);
-lean_ctor_set(x_1297, 3, x_1276);
-lean_ctor_set_uint8(x_1297, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 3, x_1297);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_1295);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1237);
+lean_ctor_set(x_1313, 0, x_1309);
+lean_ctor_set(x_1313, 1, x_2);
+lean_ctor_set(x_1313, 2, x_3);
+lean_ctor_set(x_1313, 3, x_4);
+lean_ctor_set_uint8(x_1313, sizeof(void*)*4, x_1310);
+x_1314 = 0;
+lean_ctor_set(x_1, 3, x_1313);
+lean_ctor_set(x_1, 2, x_1308);
+lean_ctor_set(x_1, 1, x_1307);
+lean_ctor_set(x_1, 0, x_1311);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1314);
 return x_1;
 }
 }
 else
 {
-lean_object* x_1298; lean_object* x_1299; lean_object* x_1300; lean_object* x_1301; lean_object* x_1302; lean_object* x_1303; lean_object* x_1304; lean_object* x_1305; lean_object* x_1306; 
-x_1298 = lean_ctor_get(x_1, 1);
-x_1299 = lean_ctor_get(x_1, 2);
-lean_inc(x_1299);
-lean_inc(x_1298);
+lean_object* x_1315; lean_object* x_1316; lean_object* x_1317; lean_object* x_1318; lean_object* x_1319; lean_object* x_1320; lean_object* x_1321; uint8_t x_1322; lean_object* x_1323; lean_object* x_1324; lean_object* x_1325; uint8_t x_1326; lean_object* x_1327; 
+x_1315 = lean_ctor_get(x_1, 1);
+x_1316 = lean_ctor_get(x_1, 2);
+lean_inc(x_1316);
+lean_inc(x_1315);
 lean_dec(x_1);
-x_1300 = lean_ctor_get(x_4, 1);
-lean_inc(x_1300);
-x_1301 = lean_ctor_get(x_4, 2);
-lean_inc(x_1301);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1302 = x_4;
+x_1317 = lean_ctor_get(x_965, 0);
+lean_inc(x_1317);
+x_1318 = lean_ctor_get(x_965, 1);
+lean_inc(x_1318);
+x_1319 = lean_ctor_get(x_965, 2);
+lean_inc(x_1319);
+x_1320 = lean_ctor_get(x_965, 3);
+lean_inc(x_1320);
+if (lean_is_exclusive(x_965)) {
+ lean_ctor_release(x_965, 0);
+ lean_ctor_release(x_965, 1);
+ lean_ctor_release(x_965, 2);
+ lean_ctor_release(x_965, 3);
+ x_1321 = x_965;
 } else {
- lean_dec_ref(x_4);
- x_1302 = lean_box(0);
+ lean_dec_ref(x_965);
+ x_1321 = lean_box(0);
 }
-lean_inc(x_234);
-if (lean_is_scalar(x_1302)) {
- x_1303 = lean_alloc_ctor(1, 4, 1);
+x_1322 = 1;
+lean_inc(x_241);
+if (lean_is_scalar(x_1321)) {
+ x_1323 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1303 = x_1302;
+ x_1323 = x_1321;
 }
-lean_ctor_set(x_1303, 0, x_234);
-lean_ctor_set(x_1303, 1, x_1298);
-lean_ctor_set(x_1303, 2, x_1299);
-lean_ctor_set(x_1303, 3, x_1276);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1304 = x_234;
+lean_ctor_set(x_1323, 0, x_241);
+lean_ctor_set(x_1323, 1, x_1315);
+lean_ctor_set(x_1323, 2, x_1316);
+lean_ctor_set(x_1323, 3, x_1317);
+if (lean_is_exclusive(x_241)) {
+ lean_ctor_release(x_241, 0);
+ lean_ctor_release(x_241, 1);
+ lean_ctor_release(x_241, 2);
+ lean_ctor_release(x_241, 3);
+ x_1324 = x_241;
 } else {
- lean_dec_ref(x_234);
- x_1304 = lean_box(0);
+ lean_dec_ref(x_241);
+ x_1324 = lean_box(0);
 }
-lean_ctor_set_uint8(x_1303, sizeof(void*)*4, x_1274);
-if (lean_is_scalar(x_1304)) {
- x_1305 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set_uint8(x_1323, sizeof(void*)*4, x_1322);
+if (lean_is_scalar(x_1324)) {
+ x_1325 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1305 = x_1304;
+ x_1325 = x_1324;
 }
-lean_ctor_set(x_1305, 0, x_1276);
-lean_ctor_set(x_1305, 1, x_1300);
-lean_ctor_set(x_1305, 2, x_1301);
-lean_ctor_set(x_1305, 3, x_1276);
-lean_ctor_set_uint8(x_1305, sizeof(void*)*4, x_1274);
-x_1306 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1306, 0, x_1303);
-lean_ctor_set(x_1306, 1, x_2);
-lean_ctor_set(x_1306, 2, x_3);
-lean_ctor_set(x_1306, 3, x_1305);
-lean_ctor_set_uint8(x_1306, sizeof(void*)*4, x_1237);
-return x_1306;
+lean_ctor_set(x_1325, 0, x_1320);
+lean_ctor_set(x_1325, 1, x_2);
+lean_ctor_set(x_1325, 2, x_3);
+lean_ctor_set(x_1325, 3, x_4);
+lean_ctor_set_uint8(x_1325, sizeof(void*)*4, x_1322);
+x_1326 = 0;
+x_1327 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1327, 0, x_1323);
+lean_ctor_set(x_1327, 1, x_1318);
+lean_ctor_set(x_1327, 2, x_1319);
+lean_ctor_set(x_1327, 3, x_1325);
+lean_ctor_set_uint8(x_1327, sizeof(void*)*4, x_1326);
+return x_1327;
 }
 }
 else
 {
-uint8_t x_1307; 
-x_1307 = lean_ctor_get_uint8(x_1276, sizeof(void*)*4);
-if (x_1307 == 0)
+uint8_t x_1328; 
+x_1328 = !lean_is_exclusive(x_1);
+if (x_1328 == 0)
 {
-uint8_t x_1308; 
-x_1308 = !lean_is_exclusive(x_1);
-if (x_1308 == 0)
+lean_object* x_1329; lean_object* x_1330; uint8_t x_1331; 
+x_1329 = lean_ctor_get(x_1, 3);
+lean_dec(x_1329);
+x_1330 = lean_ctor_get(x_1, 0);
+lean_dec(x_1330);
+x_1331 = !lean_is_exclusive(x_241);
+if (x_1331 == 0)
 {
-lean_object* x_1309; lean_object* x_1310; lean_object* x_1311; lean_object* x_1312; uint8_t x_1313; 
-x_1309 = lean_ctor_get(x_1, 1);
-x_1310 = lean_ctor_get(x_1, 2);
-x_1311 = lean_ctor_get(x_1, 3);
-lean_dec(x_1311);
-x_1312 = lean_ctor_get(x_1, 0);
-lean_dec(x_1312);
-x_1313 = !lean_is_exclusive(x_4);
-if (x_1313 == 0)
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_1286);
+if (lean_obj_tag(x_4) == 0)
 {
-lean_object* x_1314; lean_object* x_1315; lean_object* x_1316; lean_object* x_1317; uint8_t x_1318; 
-x_1314 = lean_ctor_get(x_4, 1);
-x_1315 = lean_ctor_get(x_4, 2);
-x_1316 = lean_ctor_get(x_4, 3);
-lean_dec(x_1316);
-x_1317 = lean_ctor_get(x_4, 0);
-lean_dec(x_1317);
-x_1318 = !lean_is_exclusive(x_1276);
-if (x_1318 == 0)
-{
-lean_object* x_1319; lean_object* x_1320; lean_object* x_1321; lean_object* x_1322; uint8_t x_1323; 
-x_1319 = lean_ctor_get(x_1276, 0);
-x_1320 = lean_ctor_get(x_1276, 1);
-x_1321 = lean_ctor_get(x_1276, 2);
-x_1322 = lean_ctor_get(x_1276, 3);
-lean_inc(x_234);
-lean_ctor_set(x_1276, 3, x_1275);
-lean_ctor_set(x_1276, 2, x_1310);
-lean_ctor_set(x_1276, 1, x_1309);
-lean_ctor_set(x_1276, 0, x_234);
-x_1323 = !lean_is_exclusive(x_234);
-if (x_1323 == 0)
-{
-lean_object* x_1324; lean_object* x_1325; lean_object* x_1326; lean_object* x_1327; 
-x_1324 = lean_ctor_get(x_234, 3);
-lean_dec(x_1324);
-x_1325 = lean_ctor_get(x_234, 2);
-lean_dec(x_1325);
-x_1326 = lean_ctor_get(x_234, 1);
-lean_dec(x_1326);
-x_1327 = lean_ctor_get(x_234, 0);
-lean_dec(x_1327);
-lean_ctor_set(x_4, 3, x_1275);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1276);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_234, 3, x_1322);
-lean_ctor_set(x_234, 2, x_1321);
-lean_ctor_set(x_234, 1, x_1320);
-lean_ctor_set(x_234, 0, x_1319);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1315);
-lean_ctor_set(x_1, 1, x_1314);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1307);
-return x_1;
-}
-else
-{
-lean_object* x_1328; 
-lean_dec(x_234);
-lean_ctor_set(x_4, 3, x_1275);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1276);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-x_1328 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1328, 0, x_1319);
-lean_ctor_set(x_1328, 1, x_1320);
-lean_ctor_set(x_1328, 2, x_1321);
-lean_ctor_set(x_1328, 3, x_1322);
-lean_ctor_set_uint8(x_1328, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1328);
-lean_ctor_set(x_1, 2, x_1315);
-lean_ctor_set(x_1, 1, x_1314);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1307);
-return x_1;
-}
-}
-else
-{
-lean_object* x_1329; lean_object* x_1330; lean_object* x_1331; lean_object* x_1332; lean_object* x_1333; lean_object* x_1334; lean_object* x_1335; 
-x_1329 = lean_ctor_get(x_1276, 0);
-x_1330 = lean_ctor_get(x_1276, 1);
-x_1331 = lean_ctor_get(x_1276, 2);
-x_1332 = lean_ctor_get(x_1276, 3);
-lean_inc(x_1332);
-lean_inc(x_1331);
-lean_inc(x_1330);
-lean_inc(x_1329);
-lean_dec(x_1276);
-lean_inc(x_234);
+uint8_t x_1332; lean_object* x_1333; 
+x_1332 = 1;
 x_1333 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1333, 0, x_234);
-lean_ctor_set(x_1333, 1, x_1309);
-lean_ctor_set(x_1333, 2, x_1310);
-lean_ctor_set(x_1333, 3, x_1275);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1334 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1334 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1333, sizeof(void*)*4, x_1307);
-lean_ctor_set(x_4, 3, x_1275);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1333);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1334)) {
- x_1335 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1335 = x_1334;
-}
-lean_ctor_set(x_1335, 0, x_1329);
-lean_ctor_set(x_1335, 1, x_1330);
-lean_ctor_set(x_1335, 2, x_1331);
-lean_ctor_set(x_1335, 3, x_1332);
-lean_ctor_set_uint8(x_1335, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1335);
-lean_ctor_set(x_1, 2, x_1315);
-lean_ctor_set(x_1, 1, x_1314);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1307);
-return x_1;
-}
+lean_ctor_set(x_1333, 0, x_1);
+lean_ctor_set(x_1333, 1, x_2);
+lean_ctor_set(x_1333, 2, x_3);
+lean_ctor_set(x_1333, 3, x_4);
+lean_ctor_set_uint8(x_1333, sizeof(void*)*4, x_1332);
+return x_1333;
 }
 else
 {
-lean_object* x_1336; lean_object* x_1337; lean_object* x_1338; lean_object* x_1339; lean_object* x_1340; lean_object* x_1341; lean_object* x_1342; lean_object* x_1343; lean_object* x_1344; lean_object* x_1345; lean_object* x_1346; 
-x_1336 = lean_ctor_get(x_4, 1);
-x_1337 = lean_ctor_get(x_4, 2);
-lean_inc(x_1337);
+uint8_t x_1334; 
+x_1334 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_1334 == 0)
+{
+lean_object* x_1335; 
+x_1335 = lean_ctor_get(x_4, 0);
+lean_inc(x_1335);
+if (lean_obj_tag(x_1335) == 0)
+{
+lean_object* x_1336; 
+x_1336 = lean_ctor_get(x_4, 3);
 lean_inc(x_1336);
-lean_dec(x_4);
-x_1338 = lean_ctor_get(x_1276, 0);
-lean_inc(x_1338);
-x_1339 = lean_ctor_get(x_1276, 1);
-lean_inc(x_1339);
-x_1340 = lean_ctor_get(x_1276, 2);
-lean_inc(x_1340);
-x_1341 = lean_ctor_get(x_1276, 3);
-lean_inc(x_1341);
-if (lean_is_exclusive(x_1276)) {
- lean_ctor_release(x_1276, 0);
- lean_ctor_release(x_1276, 1);
- lean_ctor_release(x_1276, 2);
- lean_ctor_release(x_1276, 3);
- x_1342 = x_1276;
-} else {
- lean_dec_ref(x_1276);
- x_1342 = lean_box(0);
-}
-lean_inc(x_234);
-if (lean_is_scalar(x_1342)) {
- x_1343 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1343 = x_1342;
-}
-lean_ctor_set(x_1343, 0, x_234);
-lean_ctor_set(x_1343, 1, x_1309);
-lean_ctor_set(x_1343, 2, x_1310);
-lean_ctor_set(x_1343, 3, x_1275);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1344 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1344 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1343, sizeof(void*)*4, x_1307);
-x_1345 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1345, 0, x_1343);
-lean_ctor_set(x_1345, 1, x_2);
-lean_ctor_set(x_1345, 2, x_3);
-lean_ctor_set(x_1345, 3, x_1275);
-lean_ctor_set_uint8(x_1345, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1344)) {
- x_1346 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1346 = x_1344;
-}
-lean_ctor_set(x_1346, 0, x_1338);
-lean_ctor_set(x_1346, 1, x_1339);
-lean_ctor_set(x_1346, 2, x_1340);
-lean_ctor_set(x_1346, 3, x_1341);
-lean_ctor_set_uint8(x_1346, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1346);
-lean_ctor_set(x_1, 2, x_1337);
-lean_ctor_set(x_1, 1, x_1336);
-lean_ctor_set(x_1, 0, x_1345);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1307);
-return x_1;
-}
+if (lean_obj_tag(x_1336) == 0)
+{
+uint8_t x_1337; lean_object* x_1338; 
+x_1337 = 1;
+x_1338 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1338, 0, x_1);
+lean_ctor_set(x_1338, 1, x_2);
+lean_ctor_set(x_1338, 2, x_3);
+lean_ctor_set(x_1338, 3, x_4);
+lean_ctor_set_uint8(x_1338, sizeof(void*)*4, x_1337);
+return x_1338;
 }
 else
 {
-lean_object* x_1347; lean_object* x_1348; lean_object* x_1349; lean_object* x_1350; lean_object* x_1351; lean_object* x_1352; lean_object* x_1353; lean_object* x_1354; lean_object* x_1355; lean_object* x_1356; lean_object* x_1357; lean_object* x_1358; lean_object* x_1359; lean_object* x_1360; lean_object* x_1361; 
-x_1347 = lean_ctor_get(x_1, 1);
-x_1348 = lean_ctor_get(x_1, 2);
-lean_inc(x_1348);
-lean_inc(x_1347);
-lean_dec(x_1);
-x_1349 = lean_ctor_get(x_4, 1);
-lean_inc(x_1349);
-x_1350 = lean_ctor_get(x_4, 2);
-lean_inc(x_1350);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1351 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1351 = lean_box(0);
+uint8_t x_1339; 
+x_1339 = lean_ctor_get_uint8(x_1336, sizeof(void*)*4);
+if (x_1339 == 0)
+{
+uint8_t x_1340; 
+x_1340 = !lean_is_exclusive(x_4);
+if (x_1340 == 0)
+{
+lean_object* x_1341; lean_object* x_1342; lean_object* x_1343; lean_object* x_1344; uint8_t x_1345; 
+x_1341 = lean_ctor_get(x_4, 1);
+x_1342 = lean_ctor_get(x_4, 2);
+x_1343 = lean_ctor_get(x_4, 3);
+lean_dec(x_1343);
+x_1344 = lean_ctor_get(x_4, 0);
+lean_dec(x_1344);
+x_1345 = !lean_is_exclusive(x_1336);
+if (x_1345 == 0)
+{
+lean_object* x_1346; lean_object* x_1347; lean_object* x_1348; lean_object* x_1349; uint8_t x_1350; uint8_t x_1351; lean_object* x_1352; 
+x_1346 = lean_ctor_get(x_1336, 0);
+x_1347 = lean_ctor_get(x_1336, 1);
+x_1348 = lean_ctor_get(x_1336, 2);
+x_1349 = lean_ctor_get(x_1336, 3);
+x_1350 = 1;
+lean_ctor_set(x_1336, 3, x_1335);
+lean_ctor_set(x_1336, 2, x_3);
+lean_ctor_set(x_1336, 1, x_2);
+lean_ctor_set(x_1336, 0, x_1);
+lean_ctor_set_uint8(x_1336, sizeof(void*)*4, x_1350);
+lean_ctor_set(x_4, 3, x_1349);
+lean_ctor_set(x_4, 2, x_1348);
+lean_ctor_set(x_4, 1, x_1347);
+lean_ctor_set(x_4, 0, x_1346);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1350);
+x_1351 = 0;
+x_1352 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1352, 0, x_1336);
+lean_ctor_set(x_1352, 1, x_1341);
+lean_ctor_set(x_1352, 2, x_1342);
+lean_ctor_set(x_1352, 3, x_4);
+lean_ctor_set_uint8(x_1352, sizeof(void*)*4, x_1351);
+return x_1352;
 }
-x_1352 = lean_ctor_get(x_1276, 0);
-lean_inc(x_1352);
-x_1353 = lean_ctor_get(x_1276, 1);
-lean_inc(x_1353);
-x_1354 = lean_ctor_get(x_1276, 2);
-lean_inc(x_1354);
-x_1355 = lean_ctor_get(x_1276, 3);
+else
+{
+lean_object* x_1353; lean_object* x_1354; lean_object* x_1355; lean_object* x_1356; uint8_t x_1357; lean_object* x_1358; uint8_t x_1359; lean_object* x_1360; 
+x_1353 = lean_ctor_get(x_1336, 0);
+x_1354 = lean_ctor_get(x_1336, 1);
+x_1355 = lean_ctor_get(x_1336, 2);
+x_1356 = lean_ctor_get(x_1336, 3);
+lean_inc(x_1356);
 lean_inc(x_1355);
-if (lean_is_exclusive(x_1276)) {
- lean_ctor_release(x_1276, 0);
- lean_ctor_release(x_1276, 1);
- lean_ctor_release(x_1276, 2);
- lean_ctor_release(x_1276, 3);
- x_1356 = x_1276;
-} else {
- lean_dec_ref(x_1276);
- x_1356 = lean_box(0);
-}
-lean_inc(x_234);
-if (lean_is_scalar(x_1356)) {
- x_1357 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1357 = x_1356;
-}
-lean_ctor_set(x_1357, 0, x_234);
-lean_ctor_set(x_1357, 1, x_1347);
-lean_ctor_set(x_1357, 2, x_1348);
-lean_ctor_set(x_1357, 3, x_1275);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1358 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1358 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1357, sizeof(void*)*4, x_1307);
-if (lean_is_scalar(x_1351)) {
- x_1359 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1359 = x_1351;
-}
-lean_ctor_set(x_1359, 0, x_1357);
-lean_ctor_set(x_1359, 1, x_2);
-lean_ctor_set(x_1359, 2, x_3);
-lean_ctor_set(x_1359, 3, x_1275);
-lean_ctor_set_uint8(x_1359, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1358)) {
- x_1360 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1360 = x_1358;
-}
-lean_ctor_set(x_1360, 0, x_1352);
-lean_ctor_set(x_1360, 1, x_1353);
-lean_ctor_set(x_1360, 2, x_1354);
-lean_ctor_set(x_1360, 3, x_1355);
-lean_ctor_set_uint8(x_1360, sizeof(void*)*4, x_1237);
-x_1361 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1361, 0, x_1359);
-lean_ctor_set(x_1361, 1, x_1349);
-lean_ctor_set(x_1361, 2, x_1350);
-lean_ctor_set(x_1361, 3, x_1360);
-lean_ctor_set_uint8(x_1361, sizeof(void*)*4, x_1307);
-return x_1361;
+lean_inc(x_1354);
+lean_inc(x_1353);
+lean_dec(x_1336);
+x_1357 = 1;
+x_1358 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1358, 0, x_1);
+lean_ctor_set(x_1358, 1, x_2);
+lean_ctor_set(x_1358, 2, x_3);
+lean_ctor_set(x_1358, 3, x_1335);
+lean_ctor_set_uint8(x_1358, sizeof(void*)*4, x_1357);
+lean_ctor_set(x_4, 3, x_1356);
+lean_ctor_set(x_4, 2, x_1355);
+lean_ctor_set(x_4, 1, x_1354);
+lean_ctor_set(x_4, 0, x_1353);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1357);
+x_1359 = 0;
+x_1360 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1360, 0, x_1358);
+lean_ctor_set(x_1360, 1, x_1341);
+lean_ctor_set(x_1360, 2, x_1342);
+lean_ctor_set(x_1360, 3, x_4);
+lean_ctor_set_uint8(x_1360, sizeof(void*)*4, x_1359);
+return x_1360;
 }
 }
 else
 {
-uint8_t x_1362; 
-x_1362 = !lean_is_exclusive(x_1276);
-if (x_1362 == 0)
-{
-lean_object* x_1363; lean_object* x_1364; lean_object* x_1365; lean_object* x_1366; uint8_t x_1367; 
-x_1363 = lean_ctor_get(x_1276, 3);
-lean_dec(x_1363);
-x_1364 = lean_ctor_get(x_1276, 2);
-lean_dec(x_1364);
-x_1365 = lean_ctor_get(x_1276, 1);
-lean_dec(x_1365);
-x_1366 = lean_ctor_get(x_1276, 0);
-lean_dec(x_1366);
-x_1367 = !lean_is_exclusive(x_1);
-if (x_1367 == 0)
-{
-lean_object* x_1368; lean_object* x_1369; lean_object* x_1370; lean_object* x_1371; uint8_t x_1372; 
-x_1368 = lean_ctor_get(x_1, 1);
-x_1369 = lean_ctor_get(x_1, 2);
-x_1370 = lean_ctor_get(x_1, 3);
-lean_dec(x_1370);
-x_1371 = lean_ctor_get(x_1, 0);
-lean_dec(x_1371);
-x_1372 = !lean_is_exclusive(x_234);
-if (x_1372 == 0)
-{
-lean_object* x_1373; lean_object* x_1374; lean_object* x_1375; lean_object* x_1376; 
-x_1373 = lean_ctor_get(x_234, 0);
-x_1374 = lean_ctor_get(x_234, 1);
-x_1375 = lean_ctor_get(x_234, 2);
-x_1376 = lean_ctor_get(x_234, 3);
-lean_ctor_set(x_1276, 3, x_1376);
-lean_ctor_set(x_1276, 2, x_1375);
-lean_ctor_set(x_1276, 1, x_1374);
-lean_ctor_set(x_1276, 0, x_1373);
-lean_ctor_set(x_234, 3, x_1275);
-lean_ctor_set(x_234, 2, x_1369);
-lean_ctor_set(x_234, 1, x_1368);
-lean_ctor_set(x_234, 0, x_1276);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1307);
-return x_1;
+lean_object* x_1361; lean_object* x_1362; lean_object* x_1363; lean_object* x_1364; lean_object* x_1365; lean_object* x_1366; lean_object* x_1367; uint8_t x_1368; lean_object* x_1369; lean_object* x_1370; uint8_t x_1371; lean_object* x_1372; 
+x_1361 = lean_ctor_get(x_4, 1);
+x_1362 = lean_ctor_get(x_4, 2);
+lean_inc(x_1362);
+lean_inc(x_1361);
+lean_dec(x_4);
+x_1363 = lean_ctor_get(x_1336, 0);
+lean_inc(x_1363);
+x_1364 = lean_ctor_get(x_1336, 1);
+lean_inc(x_1364);
+x_1365 = lean_ctor_get(x_1336, 2);
+lean_inc(x_1365);
+x_1366 = lean_ctor_get(x_1336, 3);
+lean_inc(x_1366);
+if (lean_is_exclusive(x_1336)) {
+ lean_ctor_release(x_1336, 0);
+ lean_ctor_release(x_1336, 1);
+ lean_ctor_release(x_1336, 2);
+ lean_ctor_release(x_1336, 3);
+ x_1367 = x_1336;
+} else {
+ lean_dec_ref(x_1336);
+ x_1367 = lean_box(0);
 }
-else
-{
-lean_object* x_1377; lean_object* x_1378; lean_object* x_1379; lean_object* x_1380; lean_object* x_1381; 
-x_1377 = lean_ctor_get(x_234, 0);
-x_1378 = lean_ctor_get(x_234, 1);
-x_1379 = lean_ctor_get(x_234, 2);
-x_1380 = lean_ctor_get(x_234, 3);
-lean_inc(x_1380);
-lean_inc(x_1379);
-lean_inc(x_1378);
-lean_inc(x_1377);
-lean_dec(x_234);
-lean_ctor_set(x_1276, 3, x_1380);
-lean_ctor_set(x_1276, 2, x_1379);
-lean_ctor_set(x_1276, 1, x_1378);
-lean_ctor_set(x_1276, 0, x_1377);
-x_1381 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1381, 0, x_1276);
-lean_ctor_set(x_1381, 1, x_1368);
-lean_ctor_set(x_1381, 2, x_1369);
-lean_ctor_set(x_1381, 3, x_1275);
-lean_ctor_set_uint8(x_1381, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_1381);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1307);
-return x_1;
+x_1368 = 1;
+if (lean_is_scalar(x_1367)) {
+ x_1369 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1369 = x_1367;
+}
+lean_ctor_set(x_1369, 0, x_1);
+lean_ctor_set(x_1369, 1, x_2);
+lean_ctor_set(x_1369, 2, x_3);
+lean_ctor_set(x_1369, 3, x_1335);
+lean_ctor_set_uint8(x_1369, sizeof(void*)*4, x_1368);
+x_1370 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1370, 0, x_1363);
+lean_ctor_set(x_1370, 1, x_1364);
+lean_ctor_set(x_1370, 2, x_1365);
+lean_ctor_set(x_1370, 3, x_1366);
+lean_ctor_set_uint8(x_1370, sizeof(void*)*4, x_1368);
+x_1371 = 0;
+x_1372 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1372, 0, x_1369);
+lean_ctor_set(x_1372, 1, x_1361);
+lean_ctor_set(x_1372, 2, x_1362);
+lean_ctor_set(x_1372, 3, x_1370);
+lean_ctor_set_uint8(x_1372, sizeof(void*)*4, x_1371);
+return x_1372;
 }
 }
 else
 {
-lean_object* x_1382; lean_object* x_1383; lean_object* x_1384; lean_object* x_1385; lean_object* x_1386; lean_object* x_1387; lean_object* x_1388; lean_object* x_1389; lean_object* x_1390; 
-x_1382 = lean_ctor_get(x_1, 1);
-x_1383 = lean_ctor_get(x_1, 2);
-lean_inc(x_1383);
+uint8_t x_1373; 
+x_1373 = !lean_is_exclusive(x_1336);
+if (x_1373 == 0)
+{
+lean_object* x_1374; lean_object* x_1375; lean_object* x_1376; lean_object* x_1377; uint8_t x_1378; 
+x_1374 = lean_ctor_get(x_1336, 3);
+lean_dec(x_1374);
+x_1375 = lean_ctor_get(x_1336, 2);
+lean_dec(x_1375);
+x_1376 = lean_ctor_get(x_1336, 1);
+lean_dec(x_1376);
+x_1377 = lean_ctor_get(x_1336, 0);
+lean_dec(x_1377);
+x_1378 = 1;
+lean_ctor_set(x_1336, 3, x_4);
+lean_ctor_set(x_1336, 2, x_3);
+lean_ctor_set(x_1336, 1, x_2);
+lean_ctor_set(x_1336, 0, x_1);
+lean_ctor_set_uint8(x_1336, sizeof(void*)*4, x_1378);
+return x_1336;
+}
+else
+{
+uint8_t x_1379; lean_object* x_1380; 
+lean_dec(x_1336);
+x_1379 = 1;
+x_1380 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1380, 0, x_1);
+lean_ctor_set(x_1380, 1, x_2);
+lean_ctor_set(x_1380, 2, x_3);
+lean_ctor_set(x_1380, 3, x_4);
+lean_ctor_set_uint8(x_1380, sizeof(void*)*4, x_1379);
+return x_1380;
+}
+}
+}
+}
+else
+{
+uint8_t x_1381; 
+x_1381 = lean_ctor_get_uint8(x_1335, sizeof(void*)*4);
+if (x_1381 == 0)
+{
+lean_object* x_1382; 
+x_1382 = lean_ctor_get(x_4, 3);
 lean_inc(x_1382);
-lean_dec(x_1);
-x_1384 = lean_ctor_get(x_234, 0);
-lean_inc(x_1384);
-x_1385 = lean_ctor_get(x_234, 1);
-lean_inc(x_1385);
-x_1386 = lean_ctor_get(x_234, 2);
-lean_inc(x_1386);
-x_1387 = lean_ctor_get(x_234, 3);
-lean_inc(x_1387);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1388 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1388 = lean_box(0);
-}
-lean_ctor_set(x_1276, 3, x_1387);
-lean_ctor_set(x_1276, 2, x_1386);
-lean_ctor_set(x_1276, 1, x_1385);
-lean_ctor_set(x_1276, 0, x_1384);
-if (lean_is_scalar(x_1388)) {
- x_1389 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1389 = x_1388;
-}
-lean_ctor_set(x_1389, 0, x_1276);
-lean_ctor_set(x_1389, 1, x_1382);
-lean_ctor_set(x_1389, 2, x_1383);
-lean_ctor_set(x_1389, 3, x_1275);
-lean_ctor_set_uint8(x_1389, sizeof(void*)*4, x_1274);
-x_1390 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1390, 0, x_1389);
-lean_ctor_set(x_1390, 1, x_2);
-lean_ctor_set(x_1390, 2, x_3);
-lean_ctor_set(x_1390, 3, x_4);
-lean_ctor_set_uint8(x_1390, sizeof(void*)*4, x_1307);
-return x_1390;
-}
+if (lean_obj_tag(x_1382) == 0)
+{
+uint8_t x_1383; 
+x_1383 = !lean_is_exclusive(x_4);
+if (x_1383 == 0)
+{
+lean_object* x_1384; lean_object* x_1385; uint8_t x_1386; 
+x_1384 = lean_ctor_get(x_4, 3);
+lean_dec(x_1384);
+x_1385 = lean_ctor_get(x_4, 0);
+lean_dec(x_1385);
+x_1386 = !lean_is_exclusive(x_1335);
+if (x_1386 == 0)
+{
+lean_object* x_1387; lean_object* x_1388; lean_object* x_1389; lean_object* x_1390; uint8_t x_1391; uint8_t x_1392; lean_object* x_1393; 
+x_1387 = lean_ctor_get(x_1335, 0);
+x_1388 = lean_ctor_get(x_1335, 1);
+x_1389 = lean_ctor_get(x_1335, 2);
+x_1390 = lean_ctor_get(x_1335, 3);
+x_1391 = 1;
+lean_ctor_set(x_1335, 3, x_1387);
+lean_ctor_set(x_1335, 2, x_3);
+lean_ctor_set(x_1335, 1, x_2);
+lean_ctor_set(x_1335, 0, x_1);
+lean_ctor_set_uint8(x_1335, sizeof(void*)*4, x_1391);
+lean_ctor_set(x_4, 0, x_1390);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1391);
+x_1392 = 0;
+x_1393 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1393, 0, x_1335);
+lean_ctor_set(x_1393, 1, x_1388);
+lean_ctor_set(x_1393, 2, x_1389);
+lean_ctor_set(x_1393, 3, x_4);
+lean_ctor_set_uint8(x_1393, sizeof(void*)*4, x_1392);
+return x_1393;
 }
 else
 {
-lean_object* x_1391; lean_object* x_1392; lean_object* x_1393; lean_object* x_1394; lean_object* x_1395; lean_object* x_1396; lean_object* x_1397; lean_object* x_1398; lean_object* x_1399; lean_object* x_1400; lean_object* x_1401; 
-lean_dec(x_1276);
-x_1391 = lean_ctor_get(x_1, 1);
-lean_inc(x_1391);
-x_1392 = lean_ctor_get(x_1, 2);
-lean_inc(x_1392);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_1393 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_1393 = lean_box(0);
-}
-x_1394 = lean_ctor_get(x_234, 0);
-lean_inc(x_1394);
-x_1395 = lean_ctor_get(x_234, 1);
-lean_inc(x_1395);
-x_1396 = lean_ctor_get(x_234, 2);
-lean_inc(x_1396);
-x_1397 = lean_ctor_get(x_234, 3);
+lean_object* x_1394; lean_object* x_1395; lean_object* x_1396; lean_object* x_1397; uint8_t x_1398; lean_object* x_1399; uint8_t x_1400; lean_object* x_1401; 
+x_1394 = lean_ctor_get(x_1335, 0);
+x_1395 = lean_ctor_get(x_1335, 1);
+x_1396 = lean_ctor_get(x_1335, 2);
+x_1397 = lean_ctor_get(x_1335, 3);
 lean_inc(x_1397);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1398 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1398 = lean_box(0);
-}
+lean_inc(x_1396);
+lean_inc(x_1395);
+lean_inc(x_1394);
+lean_dec(x_1335);
+x_1398 = 1;
 x_1399 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1399, 0, x_1394);
-lean_ctor_set(x_1399, 1, x_1395);
-lean_ctor_set(x_1399, 2, x_1396);
-lean_ctor_set(x_1399, 3, x_1397);
-lean_ctor_set_uint8(x_1399, sizeof(void*)*4, x_1307);
-if (lean_is_scalar(x_1398)) {
- x_1400 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1400 = x_1398;
-}
-lean_ctor_set(x_1400, 0, x_1399);
-lean_ctor_set(x_1400, 1, x_1391);
-lean_ctor_set(x_1400, 2, x_1392);
-lean_ctor_set(x_1400, 3, x_1275);
-lean_ctor_set_uint8(x_1400, sizeof(void*)*4, x_1274);
-if (lean_is_scalar(x_1393)) {
- x_1401 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1401 = x_1393;
-}
-lean_ctor_set(x_1401, 0, x_1400);
-lean_ctor_set(x_1401, 1, x_2);
-lean_ctor_set(x_1401, 2, x_3);
+lean_ctor_set(x_1399, 0, x_1);
+lean_ctor_set(x_1399, 1, x_2);
+lean_ctor_set(x_1399, 2, x_3);
+lean_ctor_set(x_1399, 3, x_1394);
+lean_ctor_set_uint8(x_1399, sizeof(void*)*4, x_1398);
+lean_ctor_set(x_4, 0, x_1397);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1398);
+x_1400 = 0;
+x_1401 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1401, 0, x_1399);
+lean_ctor_set(x_1401, 1, x_1395);
+lean_ctor_set(x_1401, 2, x_1396);
 lean_ctor_set(x_1401, 3, x_4);
-lean_ctor_set_uint8(x_1401, sizeof(void*)*4, x_1307);
+lean_ctor_set_uint8(x_1401, sizeof(void*)*4, x_1400);
 return x_1401;
 }
 }
+else
+{
+lean_object* x_1402; lean_object* x_1403; lean_object* x_1404; lean_object* x_1405; lean_object* x_1406; lean_object* x_1407; lean_object* x_1408; uint8_t x_1409; lean_object* x_1410; lean_object* x_1411; uint8_t x_1412; lean_object* x_1413; 
+x_1402 = lean_ctor_get(x_4, 1);
+x_1403 = lean_ctor_get(x_4, 2);
+lean_inc(x_1403);
+lean_inc(x_1402);
+lean_dec(x_4);
+x_1404 = lean_ctor_get(x_1335, 0);
+lean_inc(x_1404);
+x_1405 = lean_ctor_get(x_1335, 1);
+lean_inc(x_1405);
+x_1406 = lean_ctor_get(x_1335, 2);
+lean_inc(x_1406);
+x_1407 = lean_ctor_get(x_1335, 3);
+lean_inc(x_1407);
+if (lean_is_exclusive(x_1335)) {
+ lean_ctor_release(x_1335, 0);
+ lean_ctor_release(x_1335, 1);
+ lean_ctor_release(x_1335, 2);
+ lean_ctor_release(x_1335, 3);
+ x_1408 = x_1335;
+} else {
+ lean_dec_ref(x_1335);
+ x_1408 = lean_box(0);
+}
+x_1409 = 1;
+if (lean_is_scalar(x_1408)) {
+ x_1410 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1410 = x_1408;
+}
+lean_ctor_set(x_1410, 0, x_1);
+lean_ctor_set(x_1410, 1, x_2);
+lean_ctor_set(x_1410, 2, x_3);
+lean_ctor_set(x_1410, 3, x_1404);
+lean_ctor_set_uint8(x_1410, sizeof(void*)*4, x_1409);
+x_1411 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1411, 0, x_1407);
+lean_ctor_set(x_1411, 1, x_1402);
+lean_ctor_set(x_1411, 2, x_1403);
+lean_ctor_set(x_1411, 3, x_1382);
+lean_ctor_set_uint8(x_1411, sizeof(void*)*4, x_1409);
+x_1412 = 0;
+x_1413 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1413, 0, x_1410);
+lean_ctor_set(x_1413, 1, x_1405);
+lean_ctor_set(x_1413, 2, x_1406);
+lean_ctor_set(x_1413, 3, x_1411);
+lean_ctor_set_uint8(x_1413, sizeof(void*)*4, x_1412);
+return x_1413;
 }
 }
 else
 {
-uint8_t x_1402; 
-x_1402 = lean_ctor_get_uint8(x_1275, sizeof(void*)*4);
-if (x_1402 == 0)
-{
-lean_object* x_1403; 
-x_1403 = lean_ctor_get(x_4, 3);
-lean_inc(x_1403);
-if (lean_obj_tag(x_1403) == 0)
-{
-uint8_t x_1404; 
-x_1404 = !lean_is_exclusive(x_1);
-if (x_1404 == 0)
-{
-lean_object* x_1405; lean_object* x_1406; lean_object* x_1407; lean_object* x_1408; uint8_t x_1409; 
-x_1405 = lean_ctor_get(x_1, 1);
-x_1406 = lean_ctor_get(x_1, 2);
-x_1407 = lean_ctor_get(x_1, 3);
-lean_dec(x_1407);
-x_1408 = lean_ctor_get(x_1, 0);
-lean_dec(x_1408);
-x_1409 = !lean_is_exclusive(x_4);
-if (x_1409 == 0)
-{
-lean_object* x_1410; lean_object* x_1411; lean_object* x_1412; lean_object* x_1413; uint8_t x_1414; 
-x_1410 = lean_ctor_get(x_4, 1);
-x_1411 = lean_ctor_get(x_4, 2);
-x_1412 = lean_ctor_get(x_4, 3);
-lean_dec(x_1412);
-x_1413 = lean_ctor_get(x_4, 0);
-lean_dec(x_1413);
-x_1414 = !lean_is_exclusive(x_1275);
+uint8_t x_1414; 
+x_1414 = lean_ctor_get_uint8(x_1382, sizeof(void*)*4);
 if (x_1414 == 0)
 {
-lean_object* x_1415; lean_object* x_1416; lean_object* x_1417; lean_object* x_1418; uint8_t x_1419; 
-x_1415 = lean_ctor_get(x_1275, 0);
-x_1416 = lean_ctor_get(x_1275, 1);
-x_1417 = lean_ctor_get(x_1275, 2);
-x_1418 = lean_ctor_get(x_1275, 3);
-lean_inc(x_234);
-lean_ctor_set(x_1275, 3, x_1403);
-lean_ctor_set(x_1275, 2, x_1406);
-lean_ctor_set(x_1275, 1, x_1405);
-lean_ctor_set(x_1275, 0, x_234);
-x_1419 = !lean_is_exclusive(x_234);
-if (x_1419 == 0)
+uint8_t x_1415; 
+x_1415 = !lean_is_exclusive(x_4);
+if (x_1415 == 0)
 {
-lean_object* x_1420; lean_object* x_1421; lean_object* x_1422; lean_object* x_1423; 
-x_1420 = lean_ctor_get(x_234, 3);
-lean_dec(x_1420);
-x_1421 = lean_ctor_get(x_234, 2);
-lean_dec(x_1421);
-x_1422 = lean_ctor_get(x_234, 1);
-lean_dec(x_1422);
-x_1423 = lean_ctor_get(x_234, 0);
-lean_dec(x_1423);
-lean_ctor_set(x_4, 3, x_1415);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_234, 3, x_1403);
-lean_ctor_set(x_234, 2, x_1411);
-lean_ctor_set(x_234, 1, x_1410);
-lean_ctor_set(x_234, 0, x_1418);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1417);
-lean_ctor_set(x_1, 1, x_1416);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-return x_1;
+lean_object* x_1416; lean_object* x_1417; lean_object* x_1418; lean_object* x_1419; uint8_t x_1420; 
+x_1416 = lean_ctor_get(x_4, 1);
+x_1417 = lean_ctor_get(x_4, 2);
+x_1418 = lean_ctor_get(x_4, 3);
+lean_dec(x_1418);
+x_1419 = lean_ctor_get(x_4, 0);
+lean_dec(x_1419);
+x_1420 = !lean_is_exclusive(x_1335);
+if (x_1420 == 0)
+{
+uint8_t x_1421; 
+x_1421 = !lean_is_exclusive(x_1382);
+if (x_1421 == 0)
+{
+lean_object* x_1422; lean_object* x_1423; lean_object* x_1424; lean_object* x_1425; lean_object* x_1426; lean_object* x_1427; lean_object* x_1428; lean_object* x_1429; uint8_t x_1430; uint8_t x_1431; lean_object* x_1432; 
+x_1422 = lean_ctor_get(x_1335, 0);
+x_1423 = lean_ctor_get(x_1335, 1);
+x_1424 = lean_ctor_get(x_1335, 2);
+x_1425 = lean_ctor_get(x_1335, 3);
+x_1426 = lean_ctor_get(x_1382, 0);
+x_1427 = lean_ctor_get(x_1382, 1);
+x_1428 = lean_ctor_get(x_1382, 2);
+x_1429 = lean_ctor_get(x_1382, 3);
+lean_ctor_set(x_1382, 3, x_1425);
+lean_ctor_set(x_1382, 2, x_1424);
+lean_ctor_set(x_1382, 1, x_1423);
+lean_ctor_set(x_1382, 0, x_1422);
+x_1430 = 1;
+lean_ctor_set(x_1335, 3, x_1382);
+lean_ctor_set(x_1335, 2, x_3);
+lean_ctor_set(x_1335, 1, x_2);
+lean_ctor_set(x_1335, 0, x_1);
+lean_ctor_set_uint8(x_1335, sizeof(void*)*4, x_1430);
+lean_ctor_set(x_4, 3, x_1429);
+lean_ctor_set(x_4, 2, x_1428);
+lean_ctor_set(x_4, 1, x_1427);
+lean_ctor_set(x_4, 0, x_1426);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1430);
+x_1431 = 0;
+x_1432 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1432, 0, x_1335);
+lean_ctor_set(x_1432, 1, x_1416);
+lean_ctor_set(x_1432, 2, x_1417);
+lean_ctor_set(x_1432, 3, x_4);
+lean_ctor_set_uint8(x_1432, sizeof(void*)*4, x_1431);
+return x_1432;
 }
 else
 {
-lean_object* x_1424; 
-lean_dec(x_234);
-lean_ctor_set(x_4, 3, x_1415);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-x_1424 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1424, 0, x_1418);
-lean_ctor_set(x_1424, 1, x_1410);
-lean_ctor_set(x_1424, 2, x_1411);
-lean_ctor_set(x_1424, 3, x_1403);
-lean_ctor_set_uint8(x_1424, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1424);
-lean_ctor_set(x_1, 2, x_1417);
-lean_ctor_set(x_1, 1, x_1416);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-return x_1;
-}
-}
-else
-{
-lean_object* x_1425; lean_object* x_1426; lean_object* x_1427; lean_object* x_1428; lean_object* x_1429; lean_object* x_1430; lean_object* x_1431; 
-x_1425 = lean_ctor_get(x_1275, 0);
-x_1426 = lean_ctor_get(x_1275, 1);
-x_1427 = lean_ctor_get(x_1275, 2);
-x_1428 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1428);
-lean_inc(x_1427);
-lean_inc(x_1426);
-lean_inc(x_1425);
-lean_dec(x_1275);
-lean_inc(x_234);
-x_1429 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1429, 0, x_234);
-lean_ctor_set(x_1429, 1, x_1405);
-lean_ctor_set(x_1429, 2, x_1406);
-lean_ctor_set(x_1429, 3, x_1403);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1430 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1430 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1429, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_4, 3, x_1425);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1429);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1430)) {
- x_1431 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1431 = x_1430;
-}
-lean_ctor_set(x_1431, 0, x_1428);
-lean_ctor_set(x_1431, 1, x_1410);
-lean_ctor_set(x_1431, 2, x_1411);
-lean_ctor_set(x_1431, 3, x_1403);
-lean_ctor_set_uint8(x_1431, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1431);
-lean_ctor_set(x_1, 2, x_1427);
-lean_ctor_set(x_1, 1, x_1426);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-return x_1;
-}
-}
-else
-{
-lean_object* x_1432; lean_object* x_1433; lean_object* x_1434; lean_object* x_1435; lean_object* x_1436; lean_object* x_1437; lean_object* x_1438; lean_object* x_1439; lean_object* x_1440; lean_object* x_1441; lean_object* x_1442; 
-x_1432 = lean_ctor_get(x_4, 1);
-x_1433 = lean_ctor_get(x_4, 2);
-lean_inc(x_1433);
-lean_inc(x_1432);
-lean_dec(x_4);
-x_1434 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1434);
-x_1435 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1435);
-x_1436 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1436);
-x_1437 = lean_ctor_get(x_1275, 3);
+lean_object* x_1433; lean_object* x_1434; lean_object* x_1435; lean_object* x_1436; lean_object* x_1437; lean_object* x_1438; lean_object* x_1439; lean_object* x_1440; lean_object* x_1441; uint8_t x_1442; uint8_t x_1443; lean_object* x_1444; 
+x_1433 = lean_ctor_get(x_1335, 0);
+x_1434 = lean_ctor_get(x_1335, 1);
+x_1435 = lean_ctor_get(x_1335, 2);
+x_1436 = lean_ctor_get(x_1335, 3);
+x_1437 = lean_ctor_get(x_1382, 0);
+x_1438 = lean_ctor_get(x_1382, 1);
+x_1439 = lean_ctor_get(x_1382, 2);
+x_1440 = lean_ctor_get(x_1382, 3);
+lean_inc(x_1440);
+lean_inc(x_1439);
+lean_inc(x_1438);
 lean_inc(x_1437);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1438 = x_1275;
-} else {
- lean_dec_ref(x_1275);
- x_1438 = lean_box(0);
-}
-lean_inc(x_234);
-if (lean_is_scalar(x_1438)) {
- x_1439 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1439 = x_1438;
-}
-lean_ctor_set(x_1439, 0, x_234);
-lean_ctor_set(x_1439, 1, x_1405);
-lean_ctor_set(x_1439, 2, x_1406);
-lean_ctor_set(x_1439, 3, x_1403);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1440 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1440 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1439, sizeof(void*)*4, x_1402);
+lean_dec(x_1382);
 x_1441 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1441, 0, x_1439);
-lean_ctor_set(x_1441, 1, x_2);
-lean_ctor_set(x_1441, 2, x_3);
-lean_ctor_set(x_1441, 3, x_1434);
-lean_ctor_set_uint8(x_1441, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1440)) {
- x_1442 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1442 = x_1440;
-}
-lean_ctor_set(x_1442, 0, x_1437);
-lean_ctor_set(x_1442, 1, x_1432);
-lean_ctor_set(x_1442, 2, x_1433);
-lean_ctor_set(x_1442, 3, x_1403);
-lean_ctor_set_uint8(x_1442, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1442);
-lean_ctor_set(x_1, 2, x_1436);
-lean_ctor_set(x_1, 1, x_1435);
-lean_ctor_set(x_1, 0, x_1441);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-return x_1;
+lean_ctor_set(x_1441, 0, x_1433);
+lean_ctor_set(x_1441, 1, x_1434);
+lean_ctor_set(x_1441, 2, x_1435);
+lean_ctor_set(x_1441, 3, x_1436);
+lean_ctor_set_uint8(x_1441, sizeof(void*)*4, x_1414);
+x_1442 = 1;
+lean_ctor_set(x_1335, 3, x_1441);
+lean_ctor_set(x_1335, 2, x_3);
+lean_ctor_set(x_1335, 1, x_2);
+lean_ctor_set(x_1335, 0, x_1);
+lean_ctor_set_uint8(x_1335, sizeof(void*)*4, x_1442);
+lean_ctor_set(x_4, 3, x_1440);
+lean_ctor_set(x_4, 2, x_1439);
+lean_ctor_set(x_4, 1, x_1438);
+lean_ctor_set(x_4, 0, x_1437);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1442);
+x_1443 = 0;
+x_1444 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1444, 0, x_1335);
+lean_ctor_set(x_1444, 1, x_1416);
+lean_ctor_set(x_1444, 2, x_1417);
+lean_ctor_set(x_1444, 3, x_4);
+lean_ctor_set_uint8(x_1444, sizeof(void*)*4, x_1443);
+return x_1444;
 }
 }
 else
 {
-lean_object* x_1443; lean_object* x_1444; lean_object* x_1445; lean_object* x_1446; lean_object* x_1447; lean_object* x_1448; lean_object* x_1449; lean_object* x_1450; lean_object* x_1451; lean_object* x_1452; lean_object* x_1453; lean_object* x_1454; lean_object* x_1455; lean_object* x_1456; lean_object* x_1457; 
-x_1443 = lean_ctor_get(x_1, 1);
-x_1444 = lean_ctor_get(x_1, 2);
-lean_inc(x_1444);
-lean_inc(x_1443);
-lean_dec(x_1);
-x_1445 = lean_ctor_get(x_4, 1);
-lean_inc(x_1445);
-x_1446 = lean_ctor_get(x_4, 2);
-lean_inc(x_1446);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1447 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1447 = lean_box(0);
-}
-x_1448 = lean_ctor_get(x_1275, 0);
+lean_object* x_1445; lean_object* x_1446; lean_object* x_1447; lean_object* x_1448; lean_object* x_1449; lean_object* x_1450; lean_object* x_1451; lean_object* x_1452; lean_object* x_1453; lean_object* x_1454; uint8_t x_1455; lean_object* x_1456; uint8_t x_1457; lean_object* x_1458; 
+x_1445 = lean_ctor_get(x_1335, 0);
+x_1446 = lean_ctor_get(x_1335, 1);
+x_1447 = lean_ctor_get(x_1335, 2);
+x_1448 = lean_ctor_get(x_1335, 3);
 lean_inc(x_1448);
-x_1449 = lean_ctor_get(x_1275, 1);
+lean_inc(x_1447);
+lean_inc(x_1446);
+lean_inc(x_1445);
+lean_dec(x_1335);
+x_1449 = lean_ctor_get(x_1382, 0);
 lean_inc(x_1449);
-x_1450 = lean_ctor_get(x_1275, 2);
+x_1450 = lean_ctor_get(x_1382, 1);
 lean_inc(x_1450);
-x_1451 = lean_ctor_get(x_1275, 3);
+x_1451 = lean_ctor_get(x_1382, 2);
 lean_inc(x_1451);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1452 = x_1275;
+x_1452 = lean_ctor_get(x_1382, 3);
+lean_inc(x_1452);
+if (lean_is_exclusive(x_1382)) {
+ lean_ctor_release(x_1382, 0);
+ lean_ctor_release(x_1382, 1);
+ lean_ctor_release(x_1382, 2);
+ lean_ctor_release(x_1382, 3);
+ x_1453 = x_1382;
 } else {
- lean_dec_ref(x_1275);
- x_1452 = lean_box(0);
+ lean_dec_ref(x_1382);
+ x_1453 = lean_box(0);
 }
-lean_inc(x_234);
-if (lean_is_scalar(x_1452)) {
- x_1453 = lean_alloc_ctor(1, 4, 1);
+if (lean_is_scalar(x_1453)) {
+ x_1454 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1453 = x_1452;
+ x_1454 = x_1453;
 }
-lean_ctor_set(x_1453, 0, x_234);
-lean_ctor_set(x_1453, 1, x_1443);
-lean_ctor_set(x_1453, 2, x_1444);
-lean_ctor_set(x_1453, 3, x_1403);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1454 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1454 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1453, sizeof(void*)*4, x_1402);
-if (lean_is_scalar(x_1447)) {
- x_1455 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1455 = x_1447;
-}
-lean_ctor_set(x_1455, 0, x_1453);
-lean_ctor_set(x_1455, 1, x_2);
-lean_ctor_set(x_1455, 2, x_3);
-lean_ctor_set(x_1455, 3, x_1448);
-lean_ctor_set_uint8(x_1455, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1454)) {
- x_1456 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1456 = x_1454;
-}
-lean_ctor_set(x_1456, 0, x_1451);
-lean_ctor_set(x_1456, 1, x_1445);
-lean_ctor_set(x_1456, 2, x_1446);
-lean_ctor_set(x_1456, 3, x_1403);
-lean_ctor_set_uint8(x_1456, sizeof(void*)*4, x_1237);
-x_1457 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1457, 0, x_1455);
-lean_ctor_set(x_1457, 1, x_1449);
-lean_ctor_set(x_1457, 2, x_1450);
-lean_ctor_set(x_1457, 3, x_1456);
-lean_ctor_set_uint8(x_1457, sizeof(void*)*4, x_1402);
-return x_1457;
+lean_ctor_set(x_1454, 0, x_1445);
+lean_ctor_set(x_1454, 1, x_1446);
+lean_ctor_set(x_1454, 2, x_1447);
+lean_ctor_set(x_1454, 3, x_1448);
+lean_ctor_set_uint8(x_1454, sizeof(void*)*4, x_1414);
+x_1455 = 1;
+x_1456 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1456, 0, x_1);
+lean_ctor_set(x_1456, 1, x_2);
+lean_ctor_set(x_1456, 2, x_3);
+lean_ctor_set(x_1456, 3, x_1454);
+lean_ctor_set_uint8(x_1456, sizeof(void*)*4, x_1455);
+lean_ctor_set(x_4, 3, x_1452);
+lean_ctor_set(x_4, 2, x_1451);
+lean_ctor_set(x_4, 1, x_1450);
+lean_ctor_set(x_4, 0, x_1449);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1455);
+x_1457 = 0;
+x_1458 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1458, 0, x_1456);
+lean_ctor_set(x_1458, 1, x_1416);
+lean_ctor_set(x_1458, 2, x_1417);
+lean_ctor_set(x_1458, 3, x_4);
+lean_ctor_set_uint8(x_1458, sizeof(void*)*4, x_1457);
+return x_1458;
 }
 }
 else
 {
-uint8_t x_1458; 
-x_1458 = lean_ctor_get_uint8(x_1403, sizeof(void*)*4);
-if (x_1458 == 0)
+lean_object* x_1459; lean_object* x_1460; lean_object* x_1461; lean_object* x_1462; lean_object* x_1463; lean_object* x_1464; lean_object* x_1465; lean_object* x_1466; lean_object* x_1467; lean_object* x_1468; lean_object* x_1469; lean_object* x_1470; lean_object* x_1471; uint8_t x_1472; lean_object* x_1473; lean_object* x_1474; uint8_t x_1475; lean_object* x_1476; 
+x_1459 = lean_ctor_get(x_4, 1);
+x_1460 = lean_ctor_get(x_4, 2);
+lean_inc(x_1460);
+lean_inc(x_1459);
+lean_dec(x_4);
+x_1461 = lean_ctor_get(x_1335, 0);
+lean_inc(x_1461);
+x_1462 = lean_ctor_get(x_1335, 1);
+lean_inc(x_1462);
+x_1463 = lean_ctor_get(x_1335, 2);
+lean_inc(x_1463);
+x_1464 = lean_ctor_get(x_1335, 3);
+lean_inc(x_1464);
+if (lean_is_exclusive(x_1335)) {
+ lean_ctor_release(x_1335, 0);
+ lean_ctor_release(x_1335, 1);
+ lean_ctor_release(x_1335, 2);
+ lean_ctor_release(x_1335, 3);
+ x_1465 = x_1335;
+} else {
+ lean_dec_ref(x_1335);
+ x_1465 = lean_box(0);
+}
+x_1466 = lean_ctor_get(x_1382, 0);
+lean_inc(x_1466);
+x_1467 = lean_ctor_get(x_1382, 1);
+lean_inc(x_1467);
+x_1468 = lean_ctor_get(x_1382, 2);
+lean_inc(x_1468);
+x_1469 = lean_ctor_get(x_1382, 3);
+lean_inc(x_1469);
+if (lean_is_exclusive(x_1382)) {
+ lean_ctor_release(x_1382, 0);
+ lean_ctor_release(x_1382, 1);
+ lean_ctor_release(x_1382, 2);
+ lean_ctor_release(x_1382, 3);
+ x_1470 = x_1382;
+} else {
+ lean_dec_ref(x_1382);
+ x_1470 = lean_box(0);
+}
+if (lean_is_scalar(x_1470)) {
+ x_1471 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1471 = x_1470;
+}
+lean_ctor_set(x_1471, 0, x_1461);
+lean_ctor_set(x_1471, 1, x_1462);
+lean_ctor_set(x_1471, 2, x_1463);
+lean_ctor_set(x_1471, 3, x_1464);
+lean_ctor_set_uint8(x_1471, sizeof(void*)*4, x_1414);
+x_1472 = 1;
+if (lean_is_scalar(x_1465)) {
+ x_1473 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1473 = x_1465;
+}
+lean_ctor_set(x_1473, 0, x_1);
+lean_ctor_set(x_1473, 1, x_2);
+lean_ctor_set(x_1473, 2, x_3);
+lean_ctor_set(x_1473, 3, x_1471);
+lean_ctor_set_uint8(x_1473, sizeof(void*)*4, x_1472);
+x_1474 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1474, 0, x_1466);
+lean_ctor_set(x_1474, 1, x_1467);
+lean_ctor_set(x_1474, 2, x_1468);
+lean_ctor_set(x_1474, 3, x_1469);
+lean_ctor_set_uint8(x_1474, sizeof(void*)*4, x_1472);
+x_1475 = 0;
+x_1476 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1476, 0, x_1473);
+lean_ctor_set(x_1476, 1, x_1459);
+lean_ctor_set(x_1476, 2, x_1460);
+lean_ctor_set(x_1476, 3, x_1474);
+lean_ctor_set_uint8(x_1476, sizeof(void*)*4, x_1475);
+return x_1476;
+}
+}
+else
 {
-uint8_t x_1459; 
-x_1459 = !lean_is_exclusive(x_1);
-if (x_1459 == 0)
+uint8_t x_1477; 
+x_1477 = !lean_is_exclusive(x_4);
+if (x_1477 == 0)
 {
-lean_object* x_1460; lean_object* x_1461; lean_object* x_1462; lean_object* x_1463; uint8_t x_1464; 
-x_1460 = lean_ctor_get(x_1, 1);
-x_1461 = lean_ctor_get(x_1, 2);
-x_1462 = lean_ctor_get(x_1, 3);
-lean_dec(x_1462);
-x_1463 = lean_ctor_get(x_1, 0);
-lean_dec(x_1463);
-x_1464 = !lean_is_exclusive(x_4);
-if (x_1464 == 0)
-{
-lean_object* x_1465; lean_object* x_1466; lean_object* x_1467; lean_object* x_1468; uint8_t x_1469; 
-x_1465 = lean_ctor_get(x_4, 1);
-x_1466 = lean_ctor_get(x_4, 2);
-x_1467 = lean_ctor_get(x_4, 3);
-lean_dec(x_1467);
-x_1468 = lean_ctor_get(x_4, 0);
-lean_dec(x_1468);
-x_1469 = !lean_is_exclusive(x_1275);
-if (x_1469 == 0)
-{
-uint8_t x_1470; 
-x_1470 = !lean_is_exclusive(x_1403);
-if (x_1470 == 0)
-{
-lean_object* x_1471; lean_object* x_1472; lean_object* x_1473; lean_object* x_1474; uint8_t x_1475; 
-x_1471 = lean_ctor_get(x_1403, 0);
-x_1472 = lean_ctor_get(x_1403, 1);
-x_1473 = lean_ctor_get(x_1403, 2);
-x_1474 = lean_ctor_get(x_1403, 3);
-lean_inc(x_234);
-lean_ctor_set(x_1403, 3, x_1265);
-lean_ctor_set(x_1403, 2, x_1461);
-lean_ctor_set(x_1403, 1, x_1460);
-lean_ctor_set(x_1403, 0, x_234);
-x_1475 = !lean_is_exclusive(x_234);
-if (x_1475 == 0)
-{
-lean_object* x_1476; lean_object* x_1477; lean_object* x_1478; lean_object* x_1479; 
-x_1476 = lean_ctor_get(x_234, 3);
-lean_dec(x_1476);
-x_1477 = lean_ctor_get(x_234, 2);
-lean_dec(x_1477);
-x_1478 = lean_ctor_get(x_234, 1);
+lean_object* x_1478; lean_object* x_1479; uint8_t x_1480; 
+x_1478 = lean_ctor_get(x_4, 3);
 lean_dec(x_1478);
-x_1479 = lean_ctor_get(x_234, 0);
+x_1479 = lean_ctor_get(x_4, 0);
 lean_dec(x_1479);
-lean_ctor_set_uint8(x_1275, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_4, 3, x_1275);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1403);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_234, 3, x_1474);
-lean_ctor_set(x_234, 2, x_1473);
-lean_ctor_set(x_234, 1, x_1472);
-lean_ctor_set(x_234, 0, x_1471);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1466);
-lean_ctor_set(x_1, 1, x_1465);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-return x_1;
-}
-else
+x_1480 = !lean_is_exclusive(x_1335);
+if (x_1480 == 0)
 {
-lean_object* x_1480; 
-lean_dec(x_234);
-lean_ctor_set_uint8(x_1275, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_4, 3, x_1275);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1403);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-x_1480 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1480, 0, x_1471);
-lean_ctor_set(x_1480, 1, x_1472);
-lean_ctor_set(x_1480, 2, x_1473);
-lean_ctor_set(x_1480, 3, x_1474);
-lean_ctor_set_uint8(x_1480, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1480);
-lean_ctor_set(x_1, 2, x_1466);
-lean_ctor_set(x_1, 1, x_1465);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-return x_1;
-}
-}
-else
-{
-lean_object* x_1481; lean_object* x_1482; lean_object* x_1483; lean_object* x_1484; lean_object* x_1485; lean_object* x_1486; lean_object* x_1487; 
-x_1481 = lean_ctor_get(x_1403, 0);
-x_1482 = lean_ctor_get(x_1403, 1);
-x_1483 = lean_ctor_get(x_1403, 2);
-x_1484 = lean_ctor_get(x_1403, 3);
-lean_inc(x_1484);
-lean_inc(x_1483);
-lean_inc(x_1482);
-lean_inc(x_1481);
-lean_dec(x_1403);
-lean_inc(x_234);
-x_1485 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1485, 0, x_234);
-lean_ctor_set(x_1485, 1, x_1460);
-lean_ctor_set(x_1485, 2, x_1461);
-lean_ctor_set(x_1485, 3, x_1265);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1486 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1486 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1485, sizeof(void*)*4, x_1458);
-lean_ctor_set_uint8(x_1275, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_4, 3, x_1275);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1485);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1486)) {
- x_1487 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1487 = x_1486;
-}
-lean_ctor_set(x_1487, 0, x_1481);
+lean_object* x_1481; lean_object* x_1482; lean_object* x_1483; lean_object* x_1484; uint8_t x_1485; uint8_t x_1486; lean_object* x_1487; 
+x_1481 = lean_ctor_get(x_1335, 0);
+x_1482 = lean_ctor_get(x_1335, 1);
+x_1483 = lean_ctor_get(x_1335, 2);
+x_1484 = lean_ctor_get(x_1335, 3);
+x_1485 = 1;
+lean_ctor_set(x_1335, 3, x_1481);
+lean_ctor_set(x_1335, 2, x_3);
+lean_ctor_set(x_1335, 1, x_2);
+lean_ctor_set(x_1335, 0, x_1);
+lean_ctor_set_uint8(x_1335, sizeof(void*)*4, x_1485);
+lean_ctor_set(x_4, 0, x_1484);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1485);
+x_1486 = 0;
+x_1487 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1487, 0, x_1335);
 lean_ctor_set(x_1487, 1, x_1482);
 lean_ctor_set(x_1487, 2, x_1483);
-lean_ctor_set(x_1487, 3, x_1484);
-lean_ctor_set_uint8(x_1487, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1487);
-lean_ctor_set(x_1, 2, x_1466);
-lean_ctor_set(x_1, 1, x_1465);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-return x_1;
-}
+lean_ctor_set(x_1487, 3, x_4);
+lean_ctor_set_uint8(x_1487, sizeof(void*)*4, x_1486);
+return x_1487;
 }
 else
 {
-lean_object* x_1488; lean_object* x_1489; lean_object* x_1490; lean_object* x_1491; lean_object* x_1492; lean_object* x_1493; lean_object* x_1494; lean_object* x_1495; lean_object* x_1496; lean_object* x_1497; lean_object* x_1498; lean_object* x_1499; lean_object* x_1500; 
-x_1488 = lean_ctor_get(x_1275, 0);
-x_1489 = lean_ctor_get(x_1275, 1);
-x_1490 = lean_ctor_get(x_1275, 2);
-x_1491 = lean_ctor_get(x_1275, 3);
+lean_object* x_1488; lean_object* x_1489; lean_object* x_1490; lean_object* x_1491; uint8_t x_1492; lean_object* x_1493; uint8_t x_1494; lean_object* x_1495; 
+x_1488 = lean_ctor_get(x_1335, 0);
+x_1489 = lean_ctor_get(x_1335, 1);
+x_1490 = lean_ctor_get(x_1335, 2);
+x_1491 = lean_ctor_get(x_1335, 3);
 lean_inc(x_1491);
 lean_inc(x_1490);
 lean_inc(x_1489);
 lean_inc(x_1488);
-lean_dec(x_1275);
-x_1492 = lean_ctor_get(x_1403, 0);
-lean_inc(x_1492);
-x_1493 = lean_ctor_get(x_1403, 1);
-lean_inc(x_1493);
-x_1494 = lean_ctor_get(x_1403, 2);
-lean_inc(x_1494);
-x_1495 = lean_ctor_get(x_1403, 3);
-lean_inc(x_1495);
-if (lean_is_exclusive(x_1403)) {
- lean_ctor_release(x_1403, 0);
- lean_ctor_release(x_1403, 1);
- lean_ctor_release(x_1403, 2);
- lean_ctor_release(x_1403, 3);
- x_1496 = x_1403;
-} else {
- lean_dec_ref(x_1403);
- x_1496 = lean_box(0);
-}
-lean_inc(x_234);
-if (lean_is_scalar(x_1496)) {
- x_1497 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1497 = x_1496;
-}
-lean_ctor_set(x_1497, 0, x_234);
-lean_ctor_set(x_1497, 1, x_1460);
-lean_ctor_set(x_1497, 2, x_1461);
-lean_ctor_set(x_1497, 3, x_1265);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1498 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1498 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1497, sizeof(void*)*4, x_1458);
-x_1499 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1499, 0, x_1488);
-lean_ctor_set(x_1499, 1, x_1489);
-lean_ctor_set(x_1499, 2, x_1490);
-lean_ctor_set(x_1499, 3, x_1491);
-lean_ctor_set_uint8(x_1499, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_4, 3, x_1499);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_1497);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1498)) {
- x_1500 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1500 = x_1498;
-}
-lean_ctor_set(x_1500, 0, x_1492);
-lean_ctor_set(x_1500, 1, x_1493);
-lean_ctor_set(x_1500, 2, x_1494);
-lean_ctor_set(x_1500, 3, x_1495);
-lean_ctor_set_uint8(x_1500, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1500);
-lean_ctor_set(x_1, 2, x_1466);
-lean_ctor_set(x_1, 1, x_1465);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-return x_1;
+lean_dec(x_1335);
+x_1492 = 1;
+x_1493 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1493, 0, x_1);
+lean_ctor_set(x_1493, 1, x_2);
+lean_ctor_set(x_1493, 2, x_3);
+lean_ctor_set(x_1493, 3, x_1488);
+lean_ctor_set_uint8(x_1493, sizeof(void*)*4, x_1492);
+lean_ctor_set(x_4, 0, x_1491);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1492);
+x_1494 = 0;
+x_1495 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1495, 0, x_1493);
+lean_ctor_set(x_1495, 1, x_1489);
+lean_ctor_set(x_1495, 2, x_1490);
+lean_ctor_set(x_1495, 3, x_4);
+lean_ctor_set_uint8(x_1495, sizeof(void*)*4, x_1494);
+return x_1495;
 }
 }
 else
 {
-lean_object* x_1501; lean_object* x_1502; lean_object* x_1503; lean_object* x_1504; lean_object* x_1505; lean_object* x_1506; lean_object* x_1507; lean_object* x_1508; lean_object* x_1509; lean_object* x_1510; lean_object* x_1511; lean_object* x_1512; lean_object* x_1513; lean_object* x_1514; lean_object* x_1515; lean_object* x_1516; lean_object* x_1517; 
-x_1501 = lean_ctor_get(x_4, 1);
-x_1502 = lean_ctor_get(x_4, 2);
-lean_inc(x_1502);
-lean_inc(x_1501);
+lean_object* x_1496; lean_object* x_1497; lean_object* x_1498; lean_object* x_1499; lean_object* x_1500; lean_object* x_1501; lean_object* x_1502; uint8_t x_1503; lean_object* x_1504; lean_object* x_1505; uint8_t x_1506; lean_object* x_1507; 
+x_1496 = lean_ctor_get(x_4, 1);
+x_1497 = lean_ctor_get(x_4, 2);
+lean_inc(x_1497);
+lean_inc(x_1496);
 lean_dec(x_4);
-x_1503 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1503);
-x_1504 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1504);
-x_1505 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1505);
-x_1506 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1506);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1507 = x_1275;
+x_1498 = lean_ctor_get(x_1335, 0);
+lean_inc(x_1498);
+x_1499 = lean_ctor_get(x_1335, 1);
+lean_inc(x_1499);
+x_1500 = lean_ctor_get(x_1335, 2);
+lean_inc(x_1500);
+x_1501 = lean_ctor_get(x_1335, 3);
+lean_inc(x_1501);
+if (lean_is_exclusive(x_1335)) {
+ lean_ctor_release(x_1335, 0);
+ lean_ctor_release(x_1335, 1);
+ lean_ctor_release(x_1335, 2);
+ lean_ctor_release(x_1335, 3);
+ x_1502 = x_1335;
 } else {
- lean_dec_ref(x_1275);
- x_1507 = lean_box(0);
+ lean_dec_ref(x_1335);
+ x_1502 = lean_box(0);
 }
-x_1508 = lean_ctor_get(x_1403, 0);
+x_1503 = 1;
+if (lean_is_scalar(x_1502)) {
+ x_1504 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1504 = x_1502;
+}
+lean_ctor_set(x_1504, 0, x_1);
+lean_ctor_set(x_1504, 1, x_2);
+lean_ctor_set(x_1504, 2, x_3);
+lean_ctor_set(x_1504, 3, x_1498);
+lean_ctor_set_uint8(x_1504, sizeof(void*)*4, x_1503);
+x_1505 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1505, 0, x_1501);
+lean_ctor_set(x_1505, 1, x_1496);
+lean_ctor_set(x_1505, 2, x_1497);
+lean_ctor_set(x_1505, 3, x_1382);
+lean_ctor_set_uint8(x_1505, sizeof(void*)*4, x_1503);
+x_1506 = 0;
+x_1507 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1507, 0, x_1504);
+lean_ctor_set(x_1507, 1, x_1499);
+lean_ctor_set(x_1507, 2, x_1500);
+lean_ctor_set(x_1507, 3, x_1505);
+lean_ctor_set_uint8(x_1507, sizeof(void*)*4, x_1506);
+return x_1507;
+}
+}
+}
+}
+else
+{
+lean_object* x_1508; 
+x_1508 = lean_ctor_get(x_4, 3);
 lean_inc(x_1508);
-x_1509 = lean_ctor_get(x_1403, 1);
-lean_inc(x_1509);
-x_1510 = lean_ctor_get(x_1403, 2);
-lean_inc(x_1510);
-x_1511 = lean_ctor_get(x_1403, 3);
-lean_inc(x_1511);
-if (lean_is_exclusive(x_1403)) {
- lean_ctor_release(x_1403, 0);
- lean_ctor_release(x_1403, 1);
- lean_ctor_release(x_1403, 2);
- lean_ctor_release(x_1403, 3);
- x_1512 = x_1403;
-} else {
- lean_dec_ref(x_1403);
- x_1512 = lean_box(0);
+if (lean_obj_tag(x_1508) == 0)
+{
+uint8_t x_1509; 
+x_1509 = !lean_is_exclusive(x_1335);
+if (x_1509 == 0)
+{
+lean_object* x_1510; lean_object* x_1511; lean_object* x_1512; lean_object* x_1513; uint8_t x_1514; 
+x_1510 = lean_ctor_get(x_1335, 3);
+lean_dec(x_1510);
+x_1511 = lean_ctor_get(x_1335, 2);
+lean_dec(x_1511);
+x_1512 = lean_ctor_get(x_1335, 1);
+lean_dec(x_1512);
+x_1513 = lean_ctor_get(x_1335, 0);
+lean_dec(x_1513);
+x_1514 = 1;
+lean_ctor_set(x_1335, 3, x_4);
+lean_ctor_set(x_1335, 2, x_3);
+lean_ctor_set(x_1335, 1, x_2);
+lean_ctor_set(x_1335, 0, x_1);
+lean_ctor_set_uint8(x_1335, sizeof(void*)*4, x_1514);
+return x_1335;
 }
-lean_inc(x_234);
-if (lean_is_scalar(x_1512)) {
- x_1513 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1513 = x_1512;
-}
-lean_ctor_set(x_1513, 0, x_234);
-lean_ctor_set(x_1513, 1, x_1460);
-lean_ctor_set(x_1513, 2, x_1461);
-lean_ctor_set(x_1513, 3, x_1265);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1514 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1514 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1513, sizeof(void*)*4, x_1458);
-if (lean_is_scalar(x_1507)) {
- x_1515 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1515 = x_1507;
-}
-lean_ctor_set(x_1515, 0, x_1503);
-lean_ctor_set(x_1515, 1, x_1504);
-lean_ctor_set(x_1515, 2, x_1505);
-lean_ctor_set(x_1515, 3, x_1506);
-lean_ctor_set_uint8(x_1515, sizeof(void*)*4, x_1458);
+else
+{
+uint8_t x_1515; lean_object* x_1516; 
+lean_dec(x_1335);
+x_1515 = 1;
 x_1516 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1516, 0, x_1513);
+lean_ctor_set(x_1516, 0, x_1);
 lean_ctor_set(x_1516, 1, x_2);
 lean_ctor_set(x_1516, 2, x_3);
-lean_ctor_set(x_1516, 3, x_1515);
-lean_ctor_set_uint8(x_1516, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1514)) {
- x_1517 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1517 = x_1514;
-}
-lean_ctor_set(x_1517, 0, x_1508);
-lean_ctor_set(x_1517, 1, x_1509);
-lean_ctor_set(x_1517, 2, x_1510);
-lean_ctor_set(x_1517, 3, x_1511);
-lean_ctor_set_uint8(x_1517, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1517);
-lean_ctor_set(x_1, 2, x_1502);
-lean_ctor_set(x_1, 1, x_1501);
-lean_ctor_set(x_1, 0, x_1516);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-return x_1;
+lean_ctor_set(x_1516, 3, x_4);
+lean_ctor_set_uint8(x_1516, sizeof(void*)*4, x_1515);
+return x_1516;
 }
 }
 else
 {
-lean_object* x_1518; lean_object* x_1519; lean_object* x_1520; lean_object* x_1521; lean_object* x_1522; lean_object* x_1523; lean_object* x_1524; lean_object* x_1525; lean_object* x_1526; lean_object* x_1527; lean_object* x_1528; lean_object* x_1529; lean_object* x_1530; lean_object* x_1531; lean_object* x_1532; lean_object* x_1533; lean_object* x_1534; lean_object* x_1535; lean_object* x_1536; lean_object* x_1537; lean_object* x_1538; 
-x_1518 = lean_ctor_get(x_1, 1);
-x_1519 = lean_ctor_get(x_1, 2);
-lean_inc(x_1519);
-lean_inc(x_1518);
-lean_dec(x_1);
-x_1520 = lean_ctor_get(x_4, 1);
-lean_inc(x_1520);
-x_1521 = lean_ctor_get(x_4, 2);
-lean_inc(x_1521);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1522 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1522 = lean_box(0);
+uint8_t x_1517; 
+x_1517 = lean_ctor_get_uint8(x_1508, sizeof(void*)*4);
+if (x_1517 == 0)
+{
+uint8_t x_1518; 
+x_1518 = !lean_is_exclusive(x_4);
+if (x_1518 == 0)
+{
+lean_object* x_1519; lean_object* x_1520; uint8_t x_1521; 
+x_1519 = lean_ctor_get(x_4, 3);
+lean_dec(x_1519);
+x_1520 = lean_ctor_get(x_4, 0);
+lean_dec(x_1520);
+x_1521 = !lean_is_exclusive(x_1508);
+if (x_1521 == 0)
+{
+lean_object* x_1522; lean_object* x_1523; lean_object* x_1524; lean_object* x_1525; uint8_t x_1526; uint8_t x_1527; 
+x_1522 = lean_ctor_get(x_1508, 0);
+x_1523 = lean_ctor_get(x_1508, 1);
+x_1524 = lean_ctor_get(x_1508, 2);
+x_1525 = lean_ctor_get(x_1508, 3);
+x_1526 = 1;
+lean_inc(x_1335);
+lean_ctor_set(x_1508, 3, x_1335);
+lean_ctor_set(x_1508, 2, x_3);
+lean_ctor_set(x_1508, 1, x_2);
+lean_ctor_set(x_1508, 0, x_1);
+x_1527 = !lean_is_exclusive(x_1335);
+if (x_1527 == 0)
+{
+lean_object* x_1528; lean_object* x_1529; lean_object* x_1530; lean_object* x_1531; uint8_t x_1532; 
+x_1528 = lean_ctor_get(x_1335, 3);
+lean_dec(x_1528);
+x_1529 = lean_ctor_get(x_1335, 2);
+lean_dec(x_1529);
+x_1530 = lean_ctor_get(x_1335, 1);
+lean_dec(x_1530);
+x_1531 = lean_ctor_get(x_1335, 0);
+lean_dec(x_1531);
+lean_ctor_set_uint8(x_1508, sizeof(void*)*4, x_1526);
+lean_ctor_set(x_1335, 3, x_1525);
+lean_ctor_set(x_1335, 2, x_1524);
+lean_ctor_set(x_1335, 1, x_1523);
+lean_ctor_set(x_1335, 0, x_1522);
+lean_ctor_set_uint8(x_1335, sizeof(void*)*4, x_1526);
+x_1532 = 0;
+lean_ctor_set(x_4, 3, x_1335);
+lean_ctor_set(x_4, 0, x_1508);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1532);
+return x_4;
 }
-x_1523 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1523);
-x_1524 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1524);
-x_1525 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1525);
-x_1526 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1526);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1527 = x_1275;
-} else {
- lean_dec_ref(x_1275);
- x_1527 = lean_box(0);
-}
-x_1528 = lean_ctor_get(x_1403, 0);
-lean_inc(x_1528);
-x_1529 = lean_ctor_get(x_1403, 1);
-lean_inc(x_1529);
-x_1530 = lean_ctor_get(x_1403, 2);
-lean_inc(x_1530);
-x_1531 = lean_ctor_get(x_1403, 3);
-lean_inc(x_1531);
-if (lean_is_exclusive(x_1403)) {
- lean_ctor_release(x_1403, 0);
- lean_ctor_release(x_1403, 1);
- lean_ctor_release(x_1403, 2);
- lean_ctor_release(x_1403, 3);
- x_1532 = x_1403;
-} else {
- lean_dec_ref(x_1403);
- x_1532 = lean_box(0);
-}
-lean_inc(x_234);
-if (lean_is_scalar(x_1532)) {
- x_1533 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1533 = x_1532;
-}
-lean_ctor_set(x_1533, 0, x_234);
-lean_ctor_set(x_1533, 1, x_1518);
-lean_ctor_set(x_1533, 2, x_1519);
-lean_ctor_set(x_1533, 3, x_1265);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1534 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1534 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1533, sizeof(void*)*4, x_1458);
-if (lean_is_scalar(x_1527)) {
- x_1535 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1535 = x_1527;
-}
-lean_ctor_set(x_1535, 0, x_1523);
-lean_ctor_set(x_1535, 1, x_1524);
-lean_ctor_set(x_1535, 2, x_1525);
-lean_ctor_set(x_1535, 3, x_1526);
-lean_ctor_set_uint8(x_1535, sizeof(void*)*4, x_1458);
-if (lean_is_scalar(x_1522)) {
- x_1536 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1536 = x_1522;
-}
-lean_ctor_set(x_1536, 0, x_1533);
-lean_ctor_set(x_1536, 1, x_2);
-lean_ctor_set(x_1536, 2, x_3);
-lean_ctor_set(x_1536, 3, x_1535);
-lean_ctor_set_uint8(x_1536, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1534)) {
- x_1537 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1537 = x_1534;
-}
-lean_ctor_set(x_1537, 0, x_1528);
-lean_ctor_set(x_1537, 1, x_1529);
-lean_ctor_set(x_1537, 2, x_1530);
-lean_ctor_set(x_1537, 3, x_1531);
-lean_ctor_set_uint8(x_1537, sizeof(void*)*4, x_1237);
-x_1538 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1538, 0, x_1536);
-lean_ctor_set(x_1538, 1, x_1520);
-lean_ctor_set(x_1538, 2, x_1521);
-lean_ctor_set(x_1538, 3, x_1537);
-lean_ctor_set_uint8(x_1538, sizeof(void*)*4, x_1458);
-return x_1538;
+else
+{
+lean_object* x_1533; uint8_t x_1534; 
+lean_dec(x_1335);
+lean_ctor_set_uint8(x_1508, sizeof(void*)*4, x_1526);
+x_1533 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1533, 0, x_1522);
+lean_ctor_set(x_1533, 1, x_1523);
+lean_ctor_set(x_1533, 2, x_1524);
+lean_ctor_set(x_1533, 3, x_1525);
+lean_ctor_set_uint8(x_1533, sizeof(void*)*4, x_1526);
+x_1534 = 0;
+lean_ctor_set(x_4, 3, x_1533);
+lean_ctor_set(x_4, 0, x_1508);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1534);
+return x_4;
 }
 }
 else
 {
-uint8_t x_1539; 
-x_1539 = !lean_is_exclusive(x_1);
-if (x_1539 == 0)
-{
-lean_object* x_1540; lean_object* x_1541; lean_object* x_1542; lean_object* x_1543; uint8_t x_1544; 
-x_1540 = lean_ctor_get(x_1, 1);
-x_1541 = lean_ctor_get(x_1, 2);
-x_1542 = lean_ctor_get(x_1, 3);
-lean_dec(x_1542);
-x_1543 = lean_ctor_get(x_1, 0);
-lean_dec(x_1543);
-x_1544 = !lean_is_exclusive(x_234);
-if (x_1544 == 0)
-{
-uint8_t x_1545; 
-x_1545 = !lean_is_exclusive(x_4);
-if (x_1545 == 0)
-{
-lean_object* x_1546; lean_object* x_1547; lean_object* x_1548; lean_object* x_1549; lean_object* x_1550; lean_object* x_1551; lean_object* x_1552; lean_object* x_1553; uint8_t x_1554; 
-x_1546 = lean_ctor_get(x_234, 0);
-x_1547 = lean_ctor_get(x_234, 1);
-x_1548 = lean_ctor_get(x_234, 2);
-x_1549 = lean_ctor_get(x_234, 3);
-x_1550 = lean_ctor_get(x_4, 1);
-x_1551 = lean_ctor_get(x_4, 2);
-x_1552 = lean_ctor_get(x_4, 3);
-lean_dec(x_1552);
-x_1553 = lean_ctor_get(x_4, 0);
-lean_dec(x_1553);
-x_1554 = !lean_is_exclusive(x_1275);
-if (x_1554 == 0)
-{
-lean_object* x_1555; lean_object* x_1556; lean_object* x_1557; lean_object* x_1558; lean_object* x_1559; 
-x_1555 = lean_ctor_get(x_1275, 0);
-x_1556 = lean_ctor_get(x_1275, 1);
-x_1557 = lean_ctor_get(x_1275, 2);
-x_1558 = lean_ctor_get(x_1275, 3);
-lean_ctor_set(x_1275, 3, x_1549);
-lean_ctor_set(x_1275, 2, x_1548);
-lean_ctor_set(x_1275, 1, x_1547);
-lean_ctor_set(x_1275, 0, x_1546);
-lean_ctor_set_uint8(x_1275, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1541);
-lean_ctor_set(x_4, 1, x_1540);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_234, 3, x_1555);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_4);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_1, 3, x_1403);
-lean_ctor_set(x_1, 2, x_1551);
-lean_ctor_set(x_1, 1, x_1550);
-lean_ctor_set(x_1, 0, x_1558);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-x_1559 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1559, 0, x_234);
-lean_ctor_set(x_1559, 1, x_1556);
-lean_ctor_set(x_1559, 2, x_1557);
-lean_ctor_set(x_1559, 3, x_1);
-lean_ctor_set_uint8(x_1559, sizeof(void*)*4, x_1402);
-return x_1559;
+lean_object* x_1535; lean_object* x_1536; lean_object* x_1537; lean_object* x_1538; uint8_t x_1539; lean_object* x_1540; lean_object* x_1541; lean_object* x_1542; uint8_t x_1543; 
+x_1535 = lean_ctor_get(x_1508, 0);
+x_1536 = lean_ctor_get(x_1508, 1);
+x_1537 = lean_ctor_get(x_1508, 2);
+x_1538 = lean_ctor_get(x_1508, 3);
+lean_inc(x_1538);
+lean_inc(x_1537);
+lean_inc(x_1536);
+lean_inc(x_1535);
+lean_dec(x_1508);
+x_1539 = 1;
+lean_inc(x_1335);
+x_1540 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1540, 0, x_1);
+lean_ctor_set(x_1540, 1, x_2);
+lean_ctor_set(x_1540, 2, x_3);
+lean_ctor_set(x_1540, 3, x_1335);
+if (lean_is_exclusive(x_1335)) {
+ lean_ctor_release(x_1335, 0);
+ lean_ctor_release(x_1335, 1);
+ lean_ctor_release(x_1335, 2);
+ lean_ctor_release(x_1335, 3);
+ x_1541 = x_1335;
+} else {
+ lean_dec_ref(x_1335);
+ x_1541 = lean_box(0);
 }
-else
-{
-lean_object* x_1560; lean_object* x_1561; lean_object* x_1562; lean_object* x_1563; lean_object* x_1564; lean_object* x_1565; 
-x_1560 = lean_ctor_get(x_1275, 0);
-x_1561 = lean_ctor_get(x_1275, 1);
-x_1562 = lean_ctor_get(x_1275, 2);
-x_1563 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1563);
-lean_inc(x_1562);
-lean_inc(x_1561);
-lean_inc(x_1560);
-lean_dec(x_1275);
-x_1564 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1564, 0, x_1546);
-lean_ctor_set(x_1564, 1, x_1547);
-lean_ctor_set(x_1564, 2, x_1548);
-lean_ctor_set(x_1564, 3, x_1549);
-lean_ctor_set_uint8(x_1564, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1541);
-lean_ctor_set(x_4, 1, x_1540);
-lean_ctor_set(x_4, 0, x_1564);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_234, 3, x_1560);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_4);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_1, 3, x_1403);
-lean_ctor_set(x_1, 2, x_1551);
-lean_ctor_set(x_1, 1, x_1550);
-lean_ctor_set(x_1, 0, x_1563);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-x_1565 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1565, 0, x_234);
-lean_ctor_set(x_1565, 1, x_1561);
-lean_ctor_set(x_1565, 2, x_1562);
-lean_ctor_set(x_1565, 3, x_1);
-lean_ctor_set_uint8(x_1565, sizeof(void*)*4, x_1402);
-return x_1565;
+lean_ctor_set_uint8(x_1540, sizeof(void*)*4, x_1539);
+if (lean_is_scalar(x_1541)) {
+ x_1542 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1542 = x_1541;
+}
+lean_ctor_set(x_1542, 0, x_1535);
+lean_ctor_set(x_1542, 1, x_1536);
+lean_ctor_set(x_1542, 2, x_1537);
+lean_ctor_set(x_1542, 3, x_1538);
+lean_ctor_set_uint8(x_1542, sizeof(void*)*4, x_1539);
+x_1543 = 0;
+lean_ctor_set(x_4, 3, x_1542);
+lean_ctor_set(x_4, 0, x_1540);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1543);
+return x_4;
 }
 }
 else
 {
-lean_object* x_1566; lean_object* x_1567; lean_object* x_1568; lean_object* x_1569; lean_object* x_1570; lean_object* x_1571; lean_object* x_1572; lean_object* x_1573; lean_object* x_1574; lean_object* x_1575; lean_object* x_1576; lean_object* x_1577; lean_object* x_1578; lean_object* x_1579; 
-x_1566 = lean_ctor_get(x_234, 0);
-x_1567 = lean_ctor_get(x_234, 1);
-x_1568 = lean_ctor_get(x_234, 2);
-x_1569 = lean_ctor_get(x_234, 3);
-x_1570 = lean_ctor_get(x_4, 1);
-x_1571 = lean_ctor_get(x_4, 2);
-lean_inc(x_1571);
-lean_inc(x_1570);
+lean_object* x_1544; lean_object* x_1545; lean_object* x_1546; lean_object* x_1547; lean_object* x_1548; lean_object* x_1549; lean_object* x_1550; uint8_t x_1551; lean_object* x_1552; lean_object* x_1553; lean_object* x_1554; uint8_t x_1555; lean_object* x_1556; 
+x_1544 = lean_ctor_get(x_4, 1);
+x_1545 = lean_ctor_get(x_4, 2);
+lean_inc(x_1545);
+lean_inc(x_1544);
 lean_dec(x_4);
-x_1572 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1572);
-x_1573 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1573);
-x_1574 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1574);
-x_1575 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1575);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1576 = x_1275;
+x_1546 = lean_ctor_get(x_1508, 0);
+lean_inc(x_1546);
+x_1547 = lean_ctor_get(x_1508, 1);
+lean_inc(x_1547);
+x_1548 = lean_ctor_get(x_1508, 2);
+lean_inc(x_1548);
+x_1549 = lean_ctor_get(x_1508, 3);
+lean_inc(x_1549);
+if (lean_is_exclusive(x_1508)) {
+ lean_ctor_release(x_1508, 0);
+ lean_ctor_release(x_1508, 1);
+ lean_ctor_release(x_1508, 2);
+ lean_ctor_release(x_1508, 3);
+ x_1550 = x_1508;
 } else {
- lean_dec_ref(x_1275);
- x_1576 = lean_box(0);
+ lean_dec_ref(x_1508);
+ x_1550 = lean_box(0);
 }
-if (lean_is_scalar(x_1576)) {
- x_1577 = lean_alloc_ctor(1, 4, 1);
+x_1551 = 1;
+lean_inc(x_1335);
+if (lean_is_scalar(x_1550)) {
+ x_1552 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1577 = x_1576;
+ x_1552 = x_1550;
 }
-lean_ctor_set(x_1577, 0, x_1566);
-lean_ctor_set(x_1577, 1, x_1567);
-lean_ctor_set(x_1577, 2, x_1568);
-lean_ctor_set(x_1577, 3, x_1569);
-lean_ctor_set_uint8(x_1577, sizeof(void*)*4, x_1458);
-x_1578 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1578, 0, x_1577);
-lean_ctor_set(x_1578, 1, x_1540);
-lean_ctor_set(x_1578, 2, x_1541);
-lean_ctor_set(x_1578, 3, x_1265);
-lean_ctor_set_uint8(x_1578, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_234, 3, x_1572);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1578);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_1, 3, x_1403);
-lean_ctor_set(x_1, 2, x_1571);
-lean_ctor_set(x_1, 1, x_1570);
-lean_ctor_set(x_1, 0, x_1575);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-x_1579 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1579, 0, x_234);
-lean_ctor_set(x_1579, 1, x_1573);
-lean_ctor_set(x_1579, 2, x_1574);
-lean_ctor_set(x_1579, 3, x_1);
-lean_ctor_set_uint8(x_1579, sizeof(void*)*4, x_1402);
-return x_1579;
+lean_ctor_set(x_1552, 0, x_1);
+lean_ctor_set(x_1552, 1, x_2);
+lean_ctor_set(x_1552, 2, x_3);
+lean_ctor_set(x_1552, 3, x_1335);
+if (lean_is_exclusive(x_1335)) {
+ lean_ctor_release(x_1335, 0);
+ lean_ctor_release(x_1335, 1);
+ lean_ctor_release(x_1335, 2);
+ lean_ctor_release(x_1335, 3);
+ x_1553 = x_1335;
+} else {
+ lean_dec_ref(x_1335);
+ x_1553 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1552, sizeof(void*)*4, x_1551);
+if (lean_is_scalar(x_1553)) {
+ x_1554 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1554 = x_1553;
+}
+lean_ctor_set(x_1554, 0, x_1546);
+lean_ctor_set(x_1554, 1, x_1547);
+lean_ctor_set(x_1554, 2, x_1548);
+lean_ctor_set(x_1554, 3, x_1549);
+lean_ctor_set_uint8(x_1554, sizeof(void*)*4, x_1551);
+x_1555 = 0;
+x_1556 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1556, 0, x_1552);
+lean_ctor_set(x_1556, 1, x_1544);
+lean_ctor_set(x_1556, 2, x_1545);
+lean_ctor_set(x_1556, 3, x_1554);
+lean_ctor_set_uint8(x_1556, sizeof(void*)*4, x_1555);
+return x_1556;
 }
 }
 else
 {
-lean_object* x_1580; lean_object* x_1581; lean_object* x_1582; lean_object* x_1583; lean_object* x_1584; lean_object* x_1585; lean_object* x_1586; lean_object* x_1587; lean_object* x_1588; lean_object* x_1589; lean_object* x_1590; lean_object* x_1591; lean_object* x_1592; lean_object* x_1593; lean_object* x_1594; lean_object* x_1595; 
-x_1580 = lean_ctor_get(x_234, 0);
-x_1581 = lean_ctor_get(x_234, 1);
-x_1582 = lean_ctor_get(x_234, 2);
-x_1583 = lean_ctor_get(x_234, 3);
-lean_inc(x_1583);
-lean_inc(x_1582);
-lean_inc(x_1581);
+uint8_t x_1557; 
+lean_dec(x_1335);
+x_1557 = !lean_is_exclusive(x_1508);
+if (x_1557 == 0)
+{
+lean_object* x_1558; lean_object* x_1559; lean_object* x_1560; lean_object* x_1561; uint8_t x_1562; 
+x_1558 = lean_ctor_get(x_1508, 3);
+lean_dec(x_1558);
+x_1559 = lean_ctor_get(x_1508, 2);
+lean_dec(x_1559);
+x_1560 = lean_ctor_get(x_1508, 1);
+lean_dec(x_1560);
+x_1561 = lean_ctor_get(x_1508, 0);
+lean_dec(x_1561);
+x_1562 = 1;
+lean_ctor_set(x_1508, 3, x_4);
+lean_ctor_set(x_1508, 2, x_3);
+lean_ctor_set(x_1508, 1, x_2);
+lean_ctor_set(x_1508, 0, x_1);
+lean_ctor_set_uint8(x_1508, sizeof(void*)*4, x_1562);
+return x_1508;
+}
+else
+{
+uint8_t x_1563; lean_object* x_1564; 
+lean_dec(x_1508);
+x_1563 = 1;
+x_1564 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1564, 0, x_1);
+lean_ctor_set(x_1564, 1, x_2);
+lean_ctor_set(x_1564, 2, x_3);
+lean_ctor_set(x_1564, 3, x_4);
+lean_ctor_set_uint8(x_1564, sizeof(void*)*4, x_1563);
+return x_1564;
+}
+}
+}
+}
+}
+}
+else
+{
+uint8_t x_1565; lean_object* x_1566; 
+x_1565 = 1;
+x_1566 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1566, 0, x_1);
+lean_ctor_set(x_1566, 1, x_2);
+lean_ctor_set(x_1566, 2, x_3);
+lean_ctor_set(x_1566, 3, x_4);
+lean_ctor_set_uint8(x_1566, sizeof(void*)*4, x_1565);
+return x_1566;
+}
+}
+}
+else
+{
+lean_object* x_1567; lean_object* x_1568; lean_object* x_1569; lean_object* x_1570; lean_object* x_1571; 
+x_1567 = lean_ctor_get(x_241, 0);
+x_1568 = lean_ctor_get(x_241, 1);
+x_1569 = lean_ctor_get(x_241, 2);
+x_1570 = lean_ctor_get(x_241, 3);
+lean_inc(x_1570);
+lean_inc(x_1569);
+lean_inc(x_1568);
+lean_inc(x_1567);
+lean_dec(x_241);
+x_1571 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1571, 0, x_1567);
+lean_ctor_set(x_1571, 1, x_1568);
+lean_ctor_set(x_1571, 2, x_1569);
+lean_ctor_set(x_1571, 3, x_1570);
+lean_ctor_set_uint8(x_1571, sizeof(void*)*4, x_1286);
+lean_ctor_set(x_1, 0, x_1571);
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_1572; lean_object* x_1573; 
+x_1572 = 1;
+x_1573 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1573, 0, x_1);
+lean_ctor_set(x_1573, 1, x_2);
+lean_ctor_set(x_1573, 2, x_3);
+lean_ctor_set(x_1573, 3, x_4);
+lean_ctor_set_uint8(x_1573, sizeof(void*)*4, x_1572);
+return x_1573;
+}
+else
+{
+uint8_t x_1574; 
+x_1574 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_1574 == 0)
+{
+lean_object* x_1575; 
+x_1575 = lean_ctor_get(x_4, 0);
+lean_inc(x_1575);
+if (lean_obj_tag(x_1575) == 0)
+{
+lean_object* x_1576; 
+x_1576 = lean_ctor_get(x_4, 3);
+lean_inc(x_1576);
+if (lean_obj_tag(x_1576) == 0)
+{
+uint8_t x_1577; lean_object* x_1578; 
+x_1577 = 1;
+x_1578 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1578, 0, x_1);
+lean_ctor_set(x_1578, 1, x_2);
+lean_ctor_set(x_1578, 2, x_3);
+lean_ctor_set(x_1578, 3, x_4);
+lean_ctor_set_uint8(x_1578, sizeof(void*)*4, x_1577);
+return x_1578;
+}
+else
+{
+uint8_t x_1579; 
+x_1579 = lean_ctor_get_uint8(x_1576, sizeof(void*)*4);
+if (x_1579 == 0)
+{
+lean_object* x_1580; lean_object* x_1581; lean_object* x_1582; lean_object* x_1583; lean_object* x_1584; lean_object* x_1585; lean_object* x_1586; lean_object* x_1587; uint8_t x_1588; lean_object* x_1589; lean_object* x_1590; uint8_t x_1591; lean_object* x_1592; 
+x_1580 = lean_ctor_get(x_4, 1);
 lean_inc(x_1580);
-lean_dec(x_234);
-x_1584 = lean_ctor_get(x_4, 1);
-lean_inc(x_1584);
-x_1585 = lean_ctor_get(x_4, 2);
-lean_inc(x_1585);
+x_1581 = lean_ctor_get(x_4, 2);
+lean_inc(x_1581);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
- x_1586 = x_4;
+ x_1582 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_1586 = lean_box(0);
+ x_1582 = lean_box(0);
 }
-x_1587 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1587);
-x_1588 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1588);
-x_1589 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1589);
-x_1590 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1590);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1591 = x_1275;
+x_1583 = lean_ctor_get(x_1576, 0);
+lean_inc(x_1583);
+x_1584 = lean_ctor_get(x_1576, 1);
+lean_inc(x_1584);
+x_1585 = lean_ctor_get(x_1576, 2);
+lean_inc(x_1585);
+x_1586 = lean_ctor_get(x_1576, 3);
+lean_inc(x_1586);
+if (lean_is_exclusive(x_1576)) {
+ lean_ctor_release(x_1576, 0);
+ lean_ctor_release(x_1576, 1);
+ lean_ctor_release(x_1576, 2);
+ lean_ctor_release(x_1576, 3);
+ x_1587 = x_1576;
 } else {
- lean_dec_ref(x_1275);
- x_1591 = lean_box(0);
+ lean_dec_ref(x_1576);
+ x_1587 = lean_box(0);
 }
-if (lean_is_scalar(x_1591)) {
- x_1592 = lean_alloc_ctor(1, 4, 1);
+x_1588 = 1;
+if (lean_is_scalar(x_1587)) {
+ x_1589 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1592 = x_1591;
+ x_1589 = x_1587;
 }
-lean_ctor_set(x_1592, 0, x_1580);
-lean_ctor_set(x_1592, 1, x_1581);
-lean_ctor_set(x_1592, 2, x_1582);
-lean_ctor_set(x_1592, 3, x_1583);
-lean_ctor_set_uint8(x_1592, sizeof(void*)*4, x_1458);
-if (lean_is_scalar(x_1586)) {
- x_1593 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1589, 0, x_1);
+lean_ctor_set(x_1589, 1, x_2);
+lean_ctor_set(x_1589, 2, x_3);
+lean_ctor_set(x_1589, 3, x_1575);
+lean_ctor_set_uint8(x_1589, sizeof(void*)*4, x_1588);
+if (lean_is_scalar(x_1582)) {
+ x_1590 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1593 = x_1586;
+ x_1590 = x_1582;
 }
-lean_ctor_set(x_1593, 0, x_1592);
-lean_ctor_set(x_1593, 1, x_1540);
-lean_ctor_set(x_1593, 2, x_1541);
-lean_ctor_set(x_1593, 3, x_1265);
-lean_ctor_set_uint8(x_1593, sizeof(void*)*4, x_1402);
-x_1594 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1594, 0, x_1593);
-lean_ctor_set(x_1594, 1, x_2);
-lean_ctor_set(x_1594, 2, x_3);
-lean_ctor_set(x_1594, 3, x_1587);
-lean_ctor_set_uint8(x_1594, sizeof(void*)*4, x_1458);
-lean_ctor_set(x_1, 3, x_1403);
-lean_ctor_set(x_1, 2, x_1585);
-lean_ctor_set(x_1, 1, x_1584);
-lean_ctor_set(x_1, 0, x_1590);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1458);
-x_1595 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1595, 0, x_1594);
-lean_ctor_set(x_1595, 1, x_1588);
-lean_ctor_set(x_1595, 2, x_1589);
-lean_ctor_set(x_1595, 3, x_1);
-lean_ctor_set_uint8(x_1595, sizeof(void*)*4, x_1402);
+lean_ctor_set(x_1590, 0, x_1583);
+lean_ctor_set(x_1590, 1, x_1584);
+lean_ctor_set(x_1590, 2, x_1585);
+lean_ctor_set(x_1590, 3, x_1586);
+lean_ctor_set_uint8(x_1590, sizeof(void*)*4, x_1588);
+x_1591 = 0;
+x_1592 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1592, 0, x_1589);
+lean_ctor_set(x_1592, 1, x_1580);
+lean_ctor_set(x_1592, 2, x_1581);
+lean_ctor_set(x_1592, 3, x_1590);
+lean_ctor_set_uint8(x_1592, sizeof(void*)*4, x_1591);
+return x_1592;
+}
+else
+{
+lean_object* x_1593; uint8_t x_1594; lean_object* x_1595; 
+if (lean_is_exclusive(x_1576)) {
+ lean_ctor_release(x_1576, 0);
+ lean_ctor_release(x_1576, 1);
+ lean_ctor_release(x_1576, 2);
+ lean_ctor_release(x_1576, 3);
+ x_1593 = x_1576;
+} else {
+ lean_dec_ref(x_1576);
+ x_1593 = lean_box(0);
+}
+x_1594 = 1;
+if (lean_is_scalar(x_1593)) {
+ x_1595 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1595 = x_1593;
+}
+lean_ctor_set(x_1595, 0, x_1);
+lean_ctor_set(x_1595, 1, x_2);
+lean_ctor_set(x_1595, 2, x_3);
+lean_ctor_set(x_1595, 3, x_4);
+lean_ctor_set_uint8(x_1595, sizeof(void*)*4, x_1594);
 return x_1595;
 }
 }
+}
 else
 {
-lean_object* x_1596; lean_object* x_1597; lean_object* x_1598; lean_object* x_1599; lean_object* x_1600; lean_object* x_1601; lean_object* x_1602; lean_object* x_1603; lean_object* x_1604; lean_object* x_1605; lean_object* x_1606; lean_object* x_1607; lean_object* x_1608; lean_object* x_1609; lean_object* x_1610; lean_object* x_1611; lean_object* x_1612; lean_object* x_1613; lean_object* x_1614; lean_object* x_1615; 
-x_1596 = lean_ctor_get(x_1, 1);
-x_1597 = lean_ctor_get(x_1, 2);
+uint8_t x_1596; 
+x_1596 = lean_ctor_get_uint8(x_1575, sizeof(void*)*4);
+if (x_1596 == 0)
+{
+lean_object* x_1597; 
+x_1597 = lean_ctor_get(x_4, 3);
 lean_inc(x_1597);
-lean_inc(x_1596);
-lean_dec(x_1);
-x_1598 = lean_ctor_get(x_234, 0);
+if (lean_obj_tag(x_1597) == 0)
+{
+lean_object* x_1598; lean_object* x_1599; lean_object* x_1600; lean_object* x_1601; lean_object* x_1602; lean_object* x_1603; lean_object* x_1604; lean_object* x_1605; uint8_t x_1606; lean_object* x_1607; lean_object* x_1608; uint8_t x_1609; lean_object* x_1610; 
+x_1598 = lean_ctor_get(x_4, 1);
 lean_inc(x_1598);
-x_1599 = lean_ctor_get(x_234, 1);
+x_1599 = lean_ctor_get(x_4, 2);
 lean_inc(x_1599);
-x_1600 = lean_ctor_get(x_234, 2);
-lean_inc(x_1600);
-x_1601 = lean_ctor_get(x_234, 3);
-lean_inc(x_1601);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1602 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1602 = lean_box(0);
-}
-x_1603 = lean_ctor_get(x_4, 1);
-lean_inc(x_1603);
-x_1604 = lean_ctor_get(x_4, 2);
-lean_inc(x_1604);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
- x_1605 = x_4;
+ x_1600 = x_4;
 } else {
  lean_dec_ref(x_4);
+ x_1600 = lean_box(0);
+}
+x_1601 = lean_ctor_get(x_1575, 0);
+lean_inc(x_1601);
+x_1602 = lean_ctor_get(x_1575, 1);
+lean_inc(x_1602);
+x_1603 = lean_ctor_get(x_1575, 2);
+lean_inc(x_1603);
+x_1604 = lean_ctor_get(x_1575, 3);
+lean_inc(x_1604);
+if (lean_is_exclusive(x_1575)) {
+ lean_ctor_release(x_1575, 0);
+ lean_ctor_release(x_1575, 1);
+ lean_ctor_release(x_1575, 2);
+ lean_ctor_release(x_1575, 3);
+ x_1605 = x_1575;
+} else {
+ lean_dec_ref(x_1575);
  x_1605 = lean_box(0);
 }
-x_1606 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1606);
-x_1607 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1607);
-x_1608 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1608);
-x_1609 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1609);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1610 = x_1275;
-} else {
- lean_dec_ref(x_1275);
- x_1610 = lean_box(0);
-}
-if (lean_is_scalar(x_1610)) {
- x_1611 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1611 = x_1610;
-}
-lean_ctor_set(x_1611, 0, x_1598);
-lean_ctor_set(x_1611, 1, x_1599);
-lean_ctor_set(x_1611, 2, x_1600);
-lean_ctor_set(x_1611, 3, x_1601);
-lean_ctor_set_uint8(x_1611, sizeof(void*)*4, x_1458);
+x_1606 = 1;
 if (lean_is_scalar(x_1605)) {
- x_1612 = lean_alloc_ctor(1, 4, 1);
+ x_1607 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1612 = x_1605;
+ x_1607 = x_1605;
 }
-lean_ctor_set(x_1612, 0, x_1611);
-lean_ctor_set(x_1612, 1, x_1596);
-lean_ctor_set(x_1612, 2, x_1597);
-lean_ctor_set(x_1612, 3, x_1265);
-lean_ctor_set_uint8(x_1612, sizeof(void*)*4, x_1402);
-if (lean_is_scalar(x_1602)) {
- x_1613 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1607, 0, x_1);
+lean_ctor_set(x_1607, 1, x_2);
+lean_ctor_set(x_1607, 2, x_3);
+lean_ctor_set(x_1607, 3, x_1601);
+lean_ctor_set_uint8(x_1607, sizeof(void*)*4, x_1606);
+if (lean_is_scalar(x_1600)) {
+ x_1608 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1613 = x_1602;
-}
-lean_ctor_set(x_1613, 0, x_1612);
-lean_ctor_set(x_1613, 1, x_2);
-lean_ctor_set(x_1613, 2, x_3);
-lean_ctor_set(x_1613, 3, x_1606);
-lean_ctor_set_uint8(x_1613, sizeof(void*)*4, x_1458);
-x_1614 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1614, 0, x_1609);
-lean_ctor_set(x_1614, 1, x_1603);
-lean_ctor_set(x_1614, 2, x_1604);
-lean_ctor_set(x_1614, 3, x_1403);
-lean_ctor_set_uint8(x_1614, sizeof(void*)*4, x_1458);
-x_1615 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1615, 0, x_1613);
-lean_ctor_set(x_1615, 1, x_1607);
-lean_ctor_set(x_1615, 2, x_1608);
-lean_ctor_set(x_1615, 3, x_1614);
-lean_ctor_set_uint8(x_1615, sizeof(void*)*4, x_1402);
-return x_1615;
-}
-}
+ x_1608 = x_1600;
 }
+lean_ctor_set(x_1608, 0, x_1604);
+lean_ctor_set(x_1608, 1, x_1598);
+lean_ctor_set(x_1608, 2, x_1599);
+lean_ctor_set(x_1608, 3, x_1597);
+lean_ctor_set_uint8(x_1608, sizeof(void*)*4, x_1606);
+x_1609 = 0;
+x_1610 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1610, 0, x_1607);
+lean_ctor_set(x_1610, 1, x_1602);
+lean_ctor_set(x_1610, 2, x_1603);
+lean_ctor_set(x_1610, 3, x_1608);
+lean_ctor_set_uint8(x_1610, sizeof(void*)*4, x_1609);
+return x_1610;
 }
 else
 {
-lean_object* x_1616; 
-x_1616 = lean_ctor_get(x_4, 3);
+uint8_t x_1611; 
+x_1611 = lean_ctor_get_uint8(x_1597, sizeof(void*)*4);
+if (x_1611 == 0)
+{
+lean_object* x_1612; lean_object* x_1613; lean_object* x_1614; lean_object* x_1615; lean_object* x_1616; lean_object* x_1617; lean_object* x_1618; lean_object* x_1619; lean_object* x_1620; lean_object* x_1621; lean_object* x_1622; lean_object* x_1623; lean_object* x_1624; lean_object* x_1625; uint8_t x_1626; lean_object* x_1627; lean_object* x_1628; uint8_t x_1629; lean_object* x_1630; 
+x_1612 = lean_ctor_get(x_4, 1);
+lean_inc(x_1612);
+x_1613 = lean_ctor_get(x_4, 2);
+lean_inc(x_1613);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1614 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1614 = lean_box(0);
+}
+x_1615 = lean_ctor_get(x_1575, 0);
+lean_inc(x_1615);
+x_1616 = lean_ctor_get(x_1575, 1);
 lean_inc(x_1616);
-if (lean_obj_tag(x_1616) == 0)
-{
-uint8_t x_1617; 
-x_1617 = !lean_is_exclusive(x_1275);
-if (x_1617 == 0)
-{
-lean_object* x_1618; lean_object* x_1619; lean_object* x_1620; lean_object* x_1621; uint8_t x_1622; 
-x_1618 = lean_ctor_get(x_1275, 3);
-lean_dec(x_1618);
-x_1619 = lean_ctor_get(x_1275, 2);
-lean_dec(x_1619);
-x_1620 = lean_ctor_get(x_1275, 1);
-lean_dec(x_1620);
-x_1621 = lean_ctor_get(x_1275, 0);
-lean_dec(x_1621);
-x_1622 = !lean_is_exclusive(x_1);
-if (x_1622 == 0)
-{
-lean_object* x_1623; lean_object* x_1624; lean_object* x_1625; lean_object* x_1626; uint8_t x_1627; 
-x_1623 = lean_ctor_get(x_1, 1);
-x_1624 = lean_ctor_get(x_1, 2);
-x_1625 = lean_ctor_get(x_1, 3);
-lean_dec(x_1625);
-x_1626 = lean_ctor_get(x_1, 0);
-lean_dec(x_1626);
-x_1627 = !lean_is_exclusive(x_234);
-if (x_1627 == 0)
-{
-lean_object* x_1628; lean_object* x_1629; lean_object* x_1630; lean_object* x_1631; 
-x_1628 = lean_ctor_get(x_234, 0);
-x_1629 = lean_ctor_get(x_234, 1);
-x_1630 = lean_ctor_get(x_234, 2);
-x_1631 = lean_ctor_get(x_234, 3);
-lean_ctor_set(x_1275, 3, x_1631);
-lean_ctor_set(x_1275, 2, x_1630);
-lean_ctor_set(x_1275, 1, x_1629);
-lean_ctor_set(x_1275, 0, x_1628);
-lean_ctor_set(x_234, 3, x_1616);
-lean_ctor_set(x_234, 2, x_1624);
-lean_ctor_set(x_234, 1, x_1623);
-lean_ctor_set(x_234, 0, x_1275);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-return x_1;
+x_1617 = lean_ctor_get(x_1575, 2);
+lean_inc(x_1617);
+x_1618 = lean_ctor_get(x_1575, 3);
+lean_inc(x_1618);
+if (lean_is_exclusive(x_1575)) {
+ lean_ctor_release(x_1575, 0);
+ lean_ctor_release(x_1575, 1);
+ lean_ctor_release(x_1575, 2);
+ lean_ctor_release(x_1575, 3);
+ x_1619 = x_1575;
+} else {
+ lean_dec_ref(x_1575);
+ x_1619 = lean_box(0);
+}
+x_1620 = lean_ctor_get(x_1597, 0);
+lean_inc(x_1620);
+x_1621 = lean_ctor_get(x_1597, 1);
+lean_inc(x_1621);
+x_1622 = lean_ctor_get(x_1597, 2);
+lean_inc(x_1622);
+x_1623 = lean_ctor_get(x_1597, 3);
+lean_inc(x_1623);
+if (lean_is_exclusive(x_1597)) {
+ lean_ctor_release(x_1597, 0);
+ lean_ctor_release(x_1597, 1);
+ lean_ctor_release(x_1597, 2);
+ lean_ctor_release(x_1597, 3);
+ x_1624 = x_1597;
+} else {
+ lean_dec_ref(x_1597);
+ x_1624 = lean_box(0);
+}
+if (lean_is_scalar(x_1624)) {
+ x_1625 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1625 = x_1624;
+}
+lean_ctor_set(x_1625, 0, x_1615);
+lean_ctor_set(x_1625, 1, x_1616);
+lean_ctor_set(x_1625, 2, x_1617);
+lean_ctor_set(x_1625, 3, x_1618);
+lean_ctor_set_uint8(x_1625, sizeof(void*)*4, x_1611);
+x_1626 = 1;
+if (lean_is_scalar(x_1619)) {
+ x_1627 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1627 = x_1619;
+}
+lean_ctor_set(x_1627, 0, x_1);
+lean_ctor_set(x_1627, 1, x_2);
+lean_ctor_set(x_1627, 2, x_3);
+lean_ctor_set(x_1627, 3, x_1625);
+lean_ctor_set_uint8(x_1627, sizeof(void*)*4, x_1626);
+if (lean_is_scalar(x_1614)) {
+ x_1628 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1628 = x_1614;
+}
+lean_ctor_set(x_1628, 0, x_1620);
+lean_ctor_set(x_1628, 1, x_1621);
+lean_ctor_set(x_1628, 2, x_1622);
+lean_ctor_set(x_1628, 3, x_1623);
+lean_ctor_set_uint8(x_1628, sizeof(void*)*4, x_1626);
+x_1629 = 0;
+x_1630 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1630, 0, x_1627);
+lean_ctor_set(x_1630, 1, x_1612);
+lean_ctor_set(x_1630, 2, x_1613);
+lean_ctor_set(x_1630, 3, x_1628);
+lean_ctor_set_uint8(x_1630, sizeof(void*)*4, x_1629);
+return x_1630;
 }
 else
 {
-lean_object* x_1632; lean_object* x_1633; lean_object* x_1634; lean_object* x_1635; lean_object* x_1636; 
-x_1632 = lean_ctor_get(x_234, 0);
-x_1633 = lean_ctor_get(x_234, 1);
-x_1634 = lean_ctor_get(x_234, 2);
-x_1635 = lean_ctor_get(x_234, 3);
-lean_inc(x_1635);
-lean_inc(x_1634);
-lean_inc(x_1633);
+lean_object* x_1631; lean_object* x_1632; lean_object* x_1633; lean_object* x_1634; lean_object* x_1635; lean_object* x_1636; lean_object* x_1637; lean_object* x_1638; uint8_t x_1639; lean_object* x_1640; lean_object* x_1641; uint8_t x_1642; lean_object* x_1643; 
+x_1631 = lean_ctor_get(x_4, 1);
+lean_inc(x_1631);
+x_1632 = lean_ctor_get(x_4, 2);
 lean_inc(x_1632);
-lean_dec(x_234);
-lean_ctor_set(x_1275, 3, x_1635);
-lean_ctor_set(x_1275, 2, x_1634);
-lean_ctor_set(x_1275, 1, x_1633);
-lean_ctor_set(x_1275, 0, x_1632);
-x_1636 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1636, 0, x_1275);
-lean_ctor_set(x_1636, 1, x_1623);
-lean_ctor_set(x_1636, 2, x_1624);
-lean_ctor_set(x_1636, 3, x_1616);
-lean_ctor_set_uint8(x_1636, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_1636);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-return x_1;
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1633 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1633 = lean_box(0);
 }
-}
-else
-{
-lean_object* x_1637; lean_object* x_1638; lean_object* x_1639; lean_object* x_1640; lean_object* x_1641; lean_object* x_1642; lean_object* x_1643; lean_object* x_1644; lean_object* x_1645; 
-x_1637 = lean_ctor_get(x_1, 1);
-x_1638 = lean_ctor_get(x_1, 2);
-lean_inc(x_1638);
+x_1634 = lean_ctor_get(x_1575, 0);
+lean_inc(x_1634);
+x_1635 = lean_ctor_get(x_1575, 1);
+lean_inc(x_1635);
+x_1636 = lean_ctor_get(x_1575, 2);
+lean_inc(x_1636);
+x_1637 = lean_ctor_get(x_1575, 3);
 lean_inc(x_1637);
-lean_dec(x_1);
-x_1639 = lean_ctor_get(x_234, 0);
-lean_inc(x_1639);
-x_1640 = lean_ctor_get(x_234, 1);
-lean_inc(x_1640);
-x_1641 = lean_ctor_get(x_234, 2);
-lean_inc(x_1641);
-x_1642 = lean_ctor_get(x_234, 3);
-lean_inc(x_1642);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1643 = x_234;
+if (lean_is_exclusive(x_1575)) {
+ lean_ctor_release(x_1575, 0);
+ lean_ctor_release(x_1575, 1);
+ lean_ctor_release(x_1575, 2);
+ lean_ctor_release(x_1575, 3);
+ x_1638 = x_1575;
 } else {
- lean_dec_ref(x_234);
- x_1643 = lean_box(0);
+ lean_dec_ref(x_1575);
+ x_1638 = lean_box(0);
 }
-lean_ctor_set(x_1275, 3, x_1642);
-lean_ctor_set(x_1275, 2, x_1641);
-lean_ctor_set(x_1275, 1, x_1640);
-lean_ctor_set(x_1275, 0, x_1639);
-if (lean_is_scalar(x_1643)) {
- x_1644 = lean_alloc_ctor(1, 4, 1);
+x_1639 = 1;
+if (lean_is_scalar(x_1638)) {
+ x_1640 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1644 = x_1643;
+ x_1640 = x_1638;
+}
+lean_ctor_set(x_1640, 0, x_1);
+lean_ctor_set(x_1640, 1, x_2);
+lean_ctor_set(x_1640, 2, x_3);
+lean_ctor_set(x_1640, 3, x_1634);
+lean_ctor_set_uint8(x_1640, sizeof(void*)*4, x_1639);
+if (lean_is_scalar(x_1633)) {
+ x_1641 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1641 = x_1633;
+}
+lean_ctor_set(x_1641, 0, x_1637);
+lean_ctor_set(x_1641, 1, x_1631);
+lean_ctor_set(x_1641, 2, x_1632);
+lean_ctor_set(x_1641, 3, x_1597);
+lean_ctor_set_uint8(x_1641, sizeof(void*)*4, x_1639);
+x_1642 = 0;
+x_1643 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1643, 0, x_1640);
+lean_ctor_set(x_1643, 1, x_1635);
+lean_ctor_set(x_1643, 2, x_1636);
+lean_ctor_set(x_1643, 3, x_1641);
+lean_ctor_set_uint8(x_1643, sizeof(void*)*4, x_1642);
+return x_1643;
 }
-lean_ctor_set(x_1644, 0, x_1275);
-lean_ctor_set(x_1644, 1, x_1637);
-lean_ctor_set(x_1644, 2, x_1638);
-lean_ctor_set(x_1644, 3, x_1616);
-lean_ctor_set_uint8(x_1644, sizeof(void*)*4, x_1274);
-x_1645 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1645, 0, x_1644);
-lean_ctor_set(x_1645, 1, x_2);
-lean_ctor_set(x_1645, 2, x_3);
-lean_ctor_set(x_1645, 3, x_4);
-lean_ctor_set_uint8(x_1645, sizeof(void*)*4, x_1402);
-return x_1645;
 }
 }
 else
 {
-lean_object* x_1646; lean_object* x_1647; lean_object* x_1648; lean_object* x_1649; lean_object* x_1650; lean_object* x_1651; lean_object* x_1652; lean_object* x_1653; lean_object* x_1654; lean_object* x_1655; lean_object* x_1656; 
-lean_dec(x_1275);
-x_1646 = lean_ctor_get(x_1, 1);
-lean_inc(x_1646);
-x_1647 = lean_ctor_get(x_1, 2);
-lean_inc(x_1647);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_1648 = x_1;
+lean_object* x_1644; 
+x_1644 = lean_ctor_get(x_4, 3);
+lean_inc(x_1644);
+if (lean_obj_tag(x_1644) == 0)
+{
+lean_object* x_1645; uint8_t x_1646; lean_object* x_1647; 
+if (lean_is_exclusive(x_1575)) {
+ lean_ctor_release(x_1575, 0);
+ lean_ctor_release(x_1575, 1);
+ lean_ctor_release(x_1575, 2);
+ lean_ctor_release(x_1575, 3);
+ x_1645 = x_1575;
 } else {
- lean_dec_ref(x_1);
- x_1648 = lean_box(0);
+ lean_dec_ref(x_1575);
+ x_1645 = lean_box(0);
 }
-x_1649 = lean_ctor_get(x_234, 0);
+x_1646 = 1;
+if (lean_is_scalar(x_1645)) {
+ x_1647 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1647 = x_1645;
+}
+lean_ctor_set(x_1647, 0, x_1);
+lean_ctor_set(x_1647, 1, x_2);
+lean_ctor_set(x_1647, 2, x_3);
+lean_ctor_set(x_1647, 3, x_4);
+lean_ctor_set_uint8(x_1647, sizeof(void*)*4, x_1646);
+return x_1647;
+}
+else
+{
+uint8_t x_1648; 
+x_1648 = lean_ctor_get_uint8(x_1644, sizeof(void*)*4);
+if (x_1648 == 0)
+{
+lean_object* x_1649; lean_object* x_1650; lean_object* x_1651; lean_object* x_1652; lean_object* x_1653; lean_object* x_1654; lean_object* x_1655; lean_object* x_1656; uint8_t x_1657; lean_object* x_1658; lean_object* x_1659; lean_object* x_1660; uint8_t x_1661; lean_object* x_1662; 
+x_1649 = lean_ctor_get(x_4, 1);
 lean_inc(x_1649);
-x_1650 = lean_ctor_get(x_234, 1);
+x_1650 = lean_ctor_get(x_4, 2);
 lean_inc(x_1650);
-x_1651 = lean_ctor_get(x_234, 2);
-lean_inc(x_1651);
-x_1652 = lean_ctor_get(x_234, 3);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1651 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1651 = lean_box(0);
+}
+x_1652 = lean_ctor_get(x_1644, 0);
 lean_inc(x_1652);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1653 = x_234;
+x_1653 = lean_ctor_get(x_1644, 1);
+lean_inc(x_1653);
+x_1654 = lean_ctor_get(x_1644, 2);
+lean_inc(x_1654);
+x_1655 = lean_ctor_get(x_1644, 3);
+lean_inc(x_1655);
+if (lean_is_exclusive(x_1644)) {
+ lean_ctor_release(x_1644, 0);
+ lean_ctor_release(x_1644, 1);
+ lean_ctor_release(x_1644, 2);
+ lean_ctor_release(x_1644, 3);
+ x_1656 = x_1644;
 } else {
- lean_dec_ref(x_234);
- x_1653 = lean_box(0);
+ lean_dec_ref(x_1644);
+ x_1656 = lean_box(0);
 }
-x_1654 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1654, 0, x_1649);
-lean_ctor_set(x_1654, 1, x_1650);
-lean_ctor_set(x_1654, 2, x_1651);
-lean_ctor_set(x_1654, 3, x_1652);
-lean_ctor_set_uint8(x_1654, sizeof(void*)*4, x_1402);
-if (lean_is_scalar(x_1653)) {
- x_1655 = lean_alloc_ctor(1, 4, 1);
+x_1657 = 1;
+lean_inc(x_1575);
+if (lean_is_scalar(x_1656)) {
+ x_1658 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1655 = x_1653;
+ x_1658 = x_1656;
 }
-lean_ctor_set(x_1655, 0, x_1654);
-lean_ctor_set(x_1655, 1, x_1646);
-lean_ctor_set(x_1655, 2, x_1647);
-lean_ctor_set(x_1655, 3, x_1616);
-lean_ctor_set_uint8(x_1655, sizeof(void*)*4, x_1274);
-if (lean_is_scalar(x_1648)) {
- x_1656 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1658, 0, x_1);
+lean_ctor_set(x_1658, 1, x_2);
+lean_ctor_set(x_1658, 2, x_3);
+lean_ctor_set(x_1658, 3, x_1575);
+if (lean_is_exclusive(x_1575)) {
+ lean_ctor_release(x_1575, 0);
+ lean_ctor_release(x_1575, 1);
+ lean_ctor_release(x_1575, 2);
+ lean_ctor_release(x_1575, 3);
+ x_1659 = x_1575;
 } else {
- x_1656 = x_1648;
+ lean_dec_ref(x_1575);
+ x_1659 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1658, sizeof(void*)*4, x_1657);
+if (lean_is_scalar(x_1659)) {
+ x_1660 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1660 = x_1659;
+}
+lean_ctor_set(x_1660, 0, x_1652);
+lean_ctor_set(x_1660, 1, x_1653);
+lean_ctor_set(x_1660, 2, x_1654);
+lean_ctor_set(x_1660, 3, x_1655);
+lean_ctor_set_uint8(x_1660, sizeof(void*)*4, x_1657);
+x_1661 = 0;
+if (lean_is_scalar(x_1651)) {
+ x_1662 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1662 = x_1651;
+}
+lean_ctor_set(x_1662, 0, x_1658);
+lean_ctor_set(x_1662, 1, x_1649);
+lean_ctor_set(x_1662, 2, x_1650);
+lean_ctor_set(x_1662, 3, x_1660);
+lean_ctor_set_uint8(x_1662, sizeof(void*)*4, x_1661);
+return x_1662;
+}
+else
+{
+lean_object* x_1663; uint8_t x_1664; lean_object* x_1665; 
+lean_dec(x_1575);
+if (lean_is_exclusive(x_1644)) {
+ lean_ctor_release(x_1644, 0);
+ lean_ctor_release(x_1644, 1);
+ lean_ctor_release(x_1644, 2);
+ lean_ctor_release(x_1644, 3);
+ x_1663 = x_1644;
+} else {
+ lean_dec_ref(x_1644);
+ x_1663 = lean_box(0);
+}
+x_1664 = 1;
+if (lean_is_scalar(x_1663)) {
+ x_1665 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1665 = x_1663;
+}
+lean_ctor_set(x_1665, 0, x_1);
+lean_ctor_set(x_1665, 1, x_2);
+lean_ctor_set(x_1665, 2, x_3);
+lean_ctor_set(x_1665, 3, x_4);
+lean_ctor_set_uint8(x_1665, sizeof(void*)*4, x_1664);
+return x_1665;
+}
+}
 }
-lean_ctor_set(x_1656, 0, x_1655);
-lean_ctor_set(x_1656, 1, x_2);
-lean_ctor_set(x_1656, 2, x_3);
-lean_ctor_set(x_1656, 3, x_4);
-lean_ctor_set_uint8(x_1656, sizeof(void*)*4, x_1402);
-return x_1656;
 }
 }
 else
 {
-uint8_t x_1657; 
-x_1657 = lean_ctor_get_uint8(x_1616, sizeof(void*)*4);
-if (x_1657 == 0)
+uint8_t x_1666; lean_object* x_1667; 
+x_1666 = 1;
+x_1667 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1667, 0, x_1);
+lean_ctor_set(x_1667, 1, x_2);
+lean_ctor_set(x_1667, 2, x_3);
+lean_ctor_set(x_1667, 3, x_4);
+lean_ctor_set_uint8(x_1667, sizeof(void*)*4, x_1666);
+return x_1667;
+}
+}
+}
+}
+else
 {
-uint8_t x_1658; 
-x_1658 = !lean_is_exclusive(x_1);
-if (x_1658 == 0)
+lean_object* x_1668; lean_object* x_1669; lean_object* x_1670; lean_object* x_1671; lean_object* x_1672; lean_object* x_1673; lean_object* x_1674; lean_object* x_1675; lean_object* x_1676; 
+x_1668 = lean_ctor_get(x_1, 1);
+x_1669 = lean_ctor_get(x_1, 2);
+lean_inc(x_1669);
+lean_inc(x_1668);
+lean_dec(x_1);
+x_1670 = lean_ctor_get(x_241, 0);
+lean_inc(x_1670);
+x_1671 = lean_ctor_get(x_241, 1);
+lean_inc(x_1671);
+x_1672 = lean_ctor_get(x_241, 2);
+lean_inc(x_1672);
+x_1673 = lean_ctor_get(x_241, 3);
+lean_inc(x_1673);
+if (lean_is_exclusive(x_241)) {
+ lean_ctor_release(x_241, 0);
+ lean_ctor_release(x_241, 1);
+ lean_ctor_release(x_241, 2);
+ lean_ctor_release(x_241, 3);
+ x_1674 = x_241;
+} else {
+ lean_dec_ref(x_241);
+ x_1674 = lean_box(0);
+}
+if (lean_is_scalar(x_1674)) {
+ x_1675 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1675 = x_1674;
+}
+lean_ctor_set(x_1675, 0, x_1670);
+lean_ctor_set(x_1675, 1, x_1671);
+lean_ctor_set(x_1675, 2, x_1672);
+lean_ctor_set(x_1675, 3, x_1673);
+lean_ctor_set_uint8(x_1675, sizeof(void*)*4, x_1286);
+x_1676 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1676, 0, x_1675);
+lean_ctor_set(x_1676, 1, x_1668);
+lean_ctor_set(x_1676, 2, x_1669);
+lean_ctor_set(x_1676, 3, x_965);
+lean_ctor_set_uint8(x_1676, sizeof(void*)*4, x_240);
+if (lean_obj_tag(x_4) == 0)
 {
-lean_object* x_1659; lean_object* x_1660; lean_object* x_1661; lean_object* x_1662; uint8_t x_1663; 
-x_1659 = lean_ctor_get(x_1, 1);
-x_1660 = lean_ctor_get(x_1, 2);
-x_1661 = lean_ctor_get(x_1, 3);
-lean_dec(x_1661);
-x_1662 = lean_ctor_get(x_1, 0);
-lean_dec(x_1662);
-x_1663 = !lean_is_exclusive(x_234);
-if (x_1663 == 0)
-{
-uint8_t x_1664; 
-x_1664 = !lean_is_exclusive(x_4);
-if (x_1664 == 0)
-{
-lean_object* x_1665; lean_object* x_1666; lean_object* x_1667; lean_object* x_1668; lean_object* x_1669; lean_object* x_1670; lean_object* x_1671; lean_object* x_1672; uint8_t x_1673; 
-x_1665 = lean_ctor_get(x_234, 0);
-x_1666 = lean_ctor_get(x_234, 1);
-x_1667 = lean_ctor_get(x_234, 2);
-x_1668 = lean_ctor_get(x_234, 3);
-x_1669 = lean_ctor_get(x_4, 1);
-x_1670 = lean_ctor_get(x_4, 2);
-x_1671 = lean_ctor_get(x_4, 3);
-lean_dec(x_1671);
-x_1672 = lean_ctor_get(x_4, 0);
-lean_dec(x_1672);
-x_1673 = !lean_is_exclusive(x_1616);
-if (x_1673 == 0)
-{
-lean_object* x_1674; lean_object* x_1675; lean_object* x_1676; lean_object* x_1677; lean_object* x_1678; 
-x_1674 = lean_ctor_get(x_1616, 0);
-x_1675 = lean_ctor_get(x_1616, 1);
-x_1676 = lean_ctor_get(x_1616, 2);
-x_1677 = lean_ctor_get(x_1616, 3);
-lean_ctor_set(x_1616, 3, x_1668);
-lean_ctor_set(x_1616, 2, x_1667);
-lean_ctor_set(x_1616, 1, x_1666);
-lean_ctor_set(x_1616, 0, x_1665);
-lean_ctor_set_uint8(x_1616, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1660);
-lean_ctor_set(x_4, 1, x_1659);
-lean_ctor_set(x_4, 0, x_1616);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_234, 3, x_1275);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_4);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_1, 3, x_1677);
-lean_ctor_set(x_1, 2, x_1676);
-lean_ctor_set(x_1, 1, x_1675);
-lean_ctor_set(x_1, 0, x_1674);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
+uint8_t x_1677; lean_object* x_1678; 
+x_1677 = 1;
 x_1678 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1678, 0, x_234);
-lean_ctor_set(x_1678, 1, x_1669);
-lean_ctor_set(x_1678, 2, x_1670);
-lean_ctor_set(x_1678, 3, x_1);
-lean_ctor_set_uint8(x_1678, sizeof(void*)*4, x_1657);
+lean_ctor_set(x_1678, 0, x_1676);
+lean_ctor_set(x_1678, 1, x_2);
+lean_ctor_set(x_1678, 2, x_3);
+lean_ctor_set(x_1678, 3, x_4);
+lean_ctor_set_uint8(x_1678, sizeof(void*)*4, x_1677);
 return x_1678;
 }
 else
 {
-lean_object* x_1679; lean_object* x_1680; lean_object* x_1681; lean_object* x_1682; lean_object* x_1683; lean_object* x_1684; 
-x_1679 = lean_ctor_get(x_1616, 0);
-x_1680 = lean_ctor_get(x_1616, 1);
-x_1681 = lean_ctor_get(x_1616, 2);
-x_1682 = lean_ctor_get(x_1616, 3);
-lean_inc(x_1682);
-lean_inc(x_1681);
+uint8_t x_1679; 
+x_1679 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_1679 == 0)
+{
+lean_object* x_1680; 
+x_1680 = lean_ctor_get(x_4, 0);
 lean_inc(x_1680);
-lean_inc(x_1679);
-lean_dec(x_1616);
+if (lean_obj_tag(x_1680) == 0)
+{
+lean_object* x_1681; 
+x_1681 = lean_ctor_get(x_4, 3);
+lean_inc(x_1681);
+if (lean_obj_tag(x_1681) == 0)
+{
+uint8_t x_1682; lean_object* x_1683; 
+x_1682 = 1;
 x_1683 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1683, 0, x_1665);
-lean_ctor_set(x_1683, 1, x_1666);
-lean_ctor_set(x_1683, 2, x_1667);
-lean_ctor_set(x_1683, 3, x_1668);
-lean_ctor_set_uint8(x_1683, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1660);
-lean_ctor_set(x_4, 1, x_1659);
-lean_ctor_set(x_4, 0, x_1683);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_234, 3, x_1275);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_4);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_1, 3, x_1682);
-lean_ctor_set(x_1, 2, x_1681);
-lean_ctor_set(x_1, 1, x_1680);
-lean_ctor_set(x_1, 0, x_1679);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-x_1684 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1684, 0, x_234);
-lean_ctor_set(x_1684, 1, x_1669);
-lean_ctor_set(x_1684, 2, x_1670);
-lean_ctor_set(x_1684, 3, x_1);
-lean_ctor_set_uint8(x_1684, sizeof(void*)*4, x_1657);
-return x_1684;
-}
+lean_ctor_set(x_1683, 0, x_1676);
+lean_ctor_set(x_1683, 1, x_2);
+lean_ctor_set(x_1683, 2, x_3);
+lean_ctor_set(x_1683, 3, x_4);
+lean_ctor_set_uint8(x_1683, sizeof(void*)*4, x_1682);
+return x_1683;
 }
 else
 {
-lean_object* x_1685; lean_object* x_1686; lean_object* x_1687; lean_object* x_1688; lean_object* x_1689; lean_object* x_1690; lean_object* x_1691; lean_object* x_1692; lean_object* x_1693; lean_object* x_1694; lean_object* x_1695; lean_object* x_1696; lean_object* x_1697; lean_object* x_1698; 
-x_1685 = lean_ctor_get(x_234, 0);
-x_1686 = lean_ctor_get(x_234, 1);
-x_1687 = lean_ctor_get(x_234, 2);
-x_1688 = lean_ctor_get(x_234, 3);
-x_1689 = lean_ctor_get(x_4, 1);
-x_1690 = lean_ctor_get(x_4, 2);
-lean_inc(x_1690);
+uint8_t x_1684; 
+x_1684 = lean_ctor_get_uint8(x_1681, sizeof(void*)*4);
+if (x_1684 == 0)
+{
+lean_object* x_1685; lean_object* x_1686; lean_object* x_1687; lean_object* x_1688; lean_object* x_1689; lean_object* x_1690; lean_object* x_1691; lean_object* x_1692; uint8_t x_1693; lean_object* x_1694; lean_object* x_1695; uint8_t x_1696; lean_object* x_1697; 
+x_1685 = lean_ctor_get(x_4, 1);
+lean_inc(x_1685);
+x_1686 = lean_ctor_get(x_4, 2);
+lean_inc(x_1686);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1687 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1687 = lean_box(0);
+}
+x_1688 = lean_ctor_get(x_1681, 0);
+lean_inc(x_1688);
+x_1689 = lean_ctor_get(x_1681, 1);
 lean_inc(x_1689);
-lean_dec(x_4);
-x_1691 = lean_ctor_get(x_1616, 0);
+x_1690 = lean_ctor_get(x_1681, 2);
+lean_inc(x_1690);
+x_1691 = lean_ctor_get(x_1681, 3);
 lean_inc(x_1691);
-x_1692 = lean_ctor_get(x_1616, 1);
-lean_inc(x_1692);
-x_1693 = lean_ctor_get(x_1616, 2);
-lean_inc(x_1693);
-x_1694 = lean_ctor_get(x_1616, 3);
-lean_inc(x_1694);
-if (lean_is_exclusive(x_1616)) {
- lean_ctor_release(x_1616, 0);
- lean_ctor_release(x_1616, 1);
- lean_ctor_release(x_1616, 2);
- lean_ctor_release(x_1616, 3);
- x_1695 = x_1616;
+if (lean_is_exclusive(x_1681)) {
+ lean_ctor_release(x_1681, 0);
+ lean_ctor_release(x_1681, 1);
+ lean_ctor_release(x_1681, 2);
+ lean_ctor_release(x_1681, 3);
+ x_1692 = x_1681;
 } else {
- lean_dec_ref(x_1616);
- x_1695 = lean_box(0);
+ lean_dec_ref(x_1681);
+ x_1692 = lean_box(0);
 }
-if (lean_is_scalar(x_1695)) {
- x_1696 = lean_alloc_ctor(1, 4, 1);
+x_1693 = 1;
+if (lean_is_scalar(x_1692)) {
+ x_1694 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1696 = x_1695;
+ x_1694 = x_1692;
 }
-lean_ctor_set(x_1696, 0, x_1685);
-lean_ctor_set(x_1696, 1, x_1686);
-lean_ctor_set(x_1696, 2, x_1687);
-lean_ctor_set(x_1696, 3, x_1688);
-lean_ctor_set_uint8(x_1696, sizeof(void*)*4, x_1402);
+lean_ctor_set(x_1694, 0, x_1676);
+lean_ctor_set(x_1694, 1, x_2);
+lean_ctor_set(x_1694, 2, x_3);
+lean_ctor_set(x_1694, 3, x_1680);
+lean_ctor_set_uint8(x_1694, sizeof(void*)*4, x_1693);
+if (lean_is_scalar(x_1687)) {
+ x_1695 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1695 = x_1687;
+}
+lean_ctor_set(x_1695, 0, x_1688);
+lean_ctor_set(x_1695, 1, x_1689);
+lean_ctor_set(x_1695, 2, x_1690);
+lean_ctor_set(x_1695, 3, x_1691);
+lean_ctor_set_uint8(x_1695, sizeof(void*)*4, x_1693);
+x_1696 = 0;
 x_1697 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1697, 0, x_1696);
-lean_ctor_set(x_1697, 1, x_1659);
-lean_ctor_set(x_1697, 2, x_1660);
-lean_ctor_set(x_1697, 3, x_1265);
-lean_ctor_set_uint8(x_1697, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_234, 3, x_1275);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1697);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_1, 3, x_1694);
-lean_ctor_set(x_1, 2, x_1693);
-lean_ctor_set(x_1, 1, x_1692);
-lean_ctor_set(x_1, 0, x_1691);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-x_1698 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1698, 0, x_234);
-lean_ctor_set(x_1698, 1, x_1689);
-lean_ctor_set(x_1698, 2, x_1690);
-lean_ctor_set(x_1698, 3, x_1);
-lean_ctor_set_uint8(x_1698, sizeof(void*)*4, x_1657);
-return x_1698;
+lean_ctor_set(x_1697, 0, x_1694);
+lean_ctor_set(x_1697, 1, x_1685);
+lean_ctor_set(x_1697, 2, x_1686);
+lean_ctor_set(x_1697, 3, x_1695);
+lean_ctor_set_uint8(x_1697, sizeof(void*)*4, x_1696);
+return x_1697;
+}
+else
+{
+lean_object* x_1698; uint8_t x_1699; lean_object* x_1700; 
+if (lean_is_exclusive(x_1681)) {
+ lean_ctor_release(x_1681, 0);
+ lean_ctor_release(x_1681, 1);
+ lean_ctor_release(x_1681, 2);
+ lean_ctor_release(x_1681, 3);
+ x_1698 = x_1681;
+} else {
+ lean_dec_ref(x_1681);
+ x_1698 = lean_box(0);
+}
+x_1699 = 1;
+if (lean_is_scalar(x_1698)) {
+ x_1700 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1700 = x_1698;
+}
+lean_ctor_set(x_1700, 0, x_1676);
+lean_ctor_set(x_1700, 1, x_2);
+lean_ctor_set(x_1700, 2, x_3);
+lean_ctor_set(x_1700, 3, x_4);
+lean_ctor_set_uint8(x_1700, sizeof(void*)*4, x_1699);
+return x_1700;
+}
 }
 }
 else
 {
-lean_object* x_1699; lean_object* x_1700; lean_object* x_1701; lean_object* x_1702; lean_object* x_1703; lean_object* x_1704; lean_object* x_1705; lean_object* x_1706; lean_object* x_1707; lean_object* x_1708; lean_object* x_1709; lean_object* x_1710; lean_object* x_1711; lean_object* x_1712; lean_object* x_1713; lean_object* x_1714; 
-x_1699 = lean_ctor_get(x_234, 0);
-x_1700 = lean_ctor_get(x_234, 1);
-x_1701 = lean_ctor_get(x_234, 2);
-x_1702 = lean_ctor_get(x_234, 3);
+uint8_t x_1701; 
+x_1701 = lean_ctor_get_uint8(x_1680, sizeof(void*)*4);
+if (x_1701 == 0)
+{
+lean_object* x_1702; 
+x_1702 = lean_ctor_get(x_4, 3);
 lean_inc(x_1702);
-lean_inc(x_1701);
-lean_inc(x_1700);
-lean_inc(x_1699);
-lean_dec(x_234);
+if (lean_obj_tag(x_1702) == 0)
+{
+lean_object* x_1703; lean_object* x_1704; lean_object* x_1705; lean_object* x_1706; lean_object* x_1707; lean_object* x_1708; lean_object* x_1709; lean_object* x_1710; uint8_t x_1711; lean_object* x_1712; lean_object* x_1713; uint8_t x_1714; lean_object* x_1715; 
 x_1703 = lean_ctor_get(x_4, 1);
 lean_inc(x_1703);
 x_1704 = lean_ctor_get(x_4, 2);
@@ -13313,120 +14381,109 @@ if (lean_is_exclusive(x_4)) {
  lean_dec_ref(x_4);
  x_1705 = lean_box(0);
 }
-x_1706 = lean_ctor_get(x_1616, 0);
+x_1706 = lean_ctor_get(x_1680, 0);
 lean_inc(x_1706);
-x_1707 = lean_ctor_get(x_1616, 1);
+x_1707 = lean_ctor_get(x_1680, 1);
 lean_inc(x_1707);
-x_1708 = lean_ctor_get(x_1616, 2);
+x_1708 = lean_ctor_get(x_1680, 2);
 lean_inc(x_1708);
-x_1709 = lean_ctor_get(x_1616, 3);
+x_1709 = lean_ctor_get(x_1680, 3);
 lean_inc(x_1709);
-if (lean_is_exclusive(x_1616)) {
- lean_ctor_release(x_1616, 0);
- lean_ctor_release(x_1616, 1);
- lean_ctor_release(x_1616, 2);
- lean_ctor_release(x_1616, 3);
- x_1710 = x_1616;
+if (lean_is_exclusive(x_1680)) {
+ lean_ctor_release(x_1680, 0);
+ lean_ctor_release(x_1680, 1);
+ lean_ctor_release(x_1680, 2);
+ lean_ctor_release(x_1680, 3);
+ x_1710 = x_1680;
 } else {
- lean_dec_ref(x_1616);
+ lean_dec_ref(x_1680);
  x_1710 = lean_box(0);
 }
+x_1711 = 1;
 if (lean_is_scalar(x_1710)) {
- x_1711 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1711 = x_1710;
-}
-lean_ctor_set(x_1711, 0, x_1699);
-lean_ctor_set(x_1711, 1, x_1700);
-lean_ctor_set(x_1711, 2, x_1701);
-lean_ctor_set(x_1711, 3, x_1702);
-lean_ctor_set_uint8(x_1711, sizeof(void*)*4, x_1402);
-if (lean_is_scalar(x_1705)) {
  x_1712 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1712 = x_1705;
+ x_1712 = x_1710;
 }
-lean_ctor_set(x_1712, 0, x_1711);
-lean_ctor_set(x_1712, 1, x_1659);
-lean_ctor_set(x_1712, 2, x_1660);
-lean_ctor_set(x_1712, 3, x_1265);
-lean_ctor_set_uint8(x_1712, sizeof(void*)*4, x_1657);
-x_1713 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1713, 0, x_1712);
-lean_ctor_set(x_1713, 1, x_2);
-lean_ctor_set(x_1713, 2, x_3);
-lean_ctor_set(x_1713, 3, x_1275);
-lean_ctor_set_uint8(x_1713, sizeof(void*)*4, x_1402);
-lean_ctor_set(x_1, 3, x_1709);
-lean_ctor_set(x_1, 2, x_1708);
-lean_ctor_set(x_1, 1, x_1707);
-lean_ctor_set(x_1, 0, x_1706);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1402);
-x_1714 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1714, 0, x_1713);
-lean_ctor_set(x_1714, 1, x_1703);
-lean_ctor_set(x_1714, 2, x_1704);
-lean_ctor_set(x_1714, 3, x_1);
-lean_ctor_set_uint8(x_1714, sizeof(void*)*4, x_1657);
-return x_1714;
+lean_ctor_set(x_1712, 0, x_1676);
+lean_ctor_set(x_1712, 1, x_2);
+lean_ctor_set(x_1712, 2, x_3);
+lean_ctor_set(x_1712, 3, x_1706);
+lean_ctor_set_uint8(x_1712, sizeof(void*)*4, x_1711);
+if (lean_is_scalar(x_1705)) {
+ x_1713 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1713 = x_1705;
 }
+lean_ctor_set(x_1713, 0, x_1709);
+lean_ctor_set(x_1713, 1, x_1703);
+lean_ctor_set(x_1713, 2, x_1704);
+lean_ctor_set(x_1713, 3, x_1702);
+lean_ctor_set_uint8(x_1713, sizeof(void*)*4, x_1711);
+x_1714 = 0;
+x_1715 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1715, 0, x_1712);
+lean_ctor_set(x_1715, 1, x_1707);
+lean_ctor_set(x_1715, 2, x_1708);
+lean_ctor_set(x_1715, 3, x_1713);
+lean_ctor_set_uint8(x_1715, sizeof(void*)*4, x_1714);
+return x_1715;
 }
 else
 {
-lean_object* x_1715; lean_object* x_1716; lean_object* x_1717; lean_object* x_1718; lean_object* x_1719; lean_object* x_1720; lean_object* x_1721; lean_object* x_1722; lean_object* x_1723; lean_object* x_1724; lean_object* x_1725; lean_object* x_1726; lean_object* x_1727; lean_object* x_1728; lean_object* x_1729; lean_object* x_1730; lean_object* x_1731; lean_object* x_1732; lean_object* x_1733; lean_object* x_1734; 
-x_1715 = lean_ctor_get(x_1, 1);
-x_1716 = lean_ctor_get(x_1, 2);
-lean_inc(x_1716);
-lean_inc(x_1715);
-lean_dec(x_1);
-x_1717 = lean_ctor_get(x_234, 0);
+uint8_t x_1716; 
+x_1716 = lean_ctor_get_uint8(x_1702, sizeof(void*)*4);
+if (x_1716 == 0)
+{
+lean_object* x_1717; lean_object* x_1718; lean_object* x_1719; lean_object* x_1720; lean_object* x_1721; lean_object* x_1722; lean_object* x_1723; lean_object* x_1724; lean_object* x_1725; lean_object* x_1726; lean_object* x_1727; lean_object* x_1728; lean_object* x_1729; lean_object* x_1730; uint8_t x_1731; lean_object* x_1732; lean_object* x_1733; uint8_t x_1734; lean_object* x_1735; 
+x_1717 = lean_ctor_get(x_4, 1);
 lean_inc(x_1717);
-x_1718 = lean_ctor_get(x_234, 1);
+x_1718 = lean_ctor_get(x_4, 2);
 lean_inc(x_1718);
-x_1719 = lean_ctor_get(x_234, 2);
-lean_inc(x_1719);
-x_1720 = lean_ctor_get(x_234, 3);
-lean_inc(x_1720);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1721 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1721 = lean_box(0);
-}
-x_1722 = lean_ctor_get(x_4, 1);
-lean_inc(x_1722);
-x_1723 = lean_ctor_get(x_4, 2);
-lean_inc(x_1723);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
- x_1724 = x_4;
+ x_1719 = x_4;
 } else {
  lean_dec_ref(x_4);
+ x_1719 = lean_box(0);
+}
+x_1720 = lean_ctor_get(x_1680, 0);
+lean_inc(x_1720);
+x_1721 = lean_ctor_get(x_1680, 1);
+lean_inc(x_1721);
+x_1722 = lean_ctor_get(x_1680, 2);
+lean_inc(x_1722);
+x_1723 = lean_ctor_get(x_1680, 3);
+lean_inc(x_1723);
+if (lean_is_exclusive(x_1680)) {
+ lean_ctor_release(x_1680, 0);
+ lean_ctor_release(x_1680, 1);
+ lean_ctor_release(x_1680, 2);
+ lean_ctor_release(x_1680, 3);
+ x_1724 = x_1680;
+} else {
+ lean_dec_ref(x_1680);
  x_1724 = lean_box(0);
 }
-x_1725 = lean_ctor_get(x_1616, 0);
+x_1725 = lean_ctor_get(x_1702, 0);
 lean_inc(x_1725);
-x_1726 = lean_ctor_get(x_1616, 1);
+x_1726 = lean_ctor_get(x_1702, 1);
 lean_inc(x_1726);
-x_1727 = lean_ctor_get(x_1616, 2);
+x_1727 = lean_ctor_get(x_1702, 2);
 lean_inc(x_1727);
-x_1728 = lean_ctor_get(x_1616, 3);
+x_1728 = lean_ctor_get(x_1702, 3);
 lean_inc(x_1728);
-if (lean_is_exclusive(x_1616)) {
- lean_ctor_release(x_1616, 0);
- lean_ctor_release(x_1616, 1);
- lean_ctor_release(x_1616, 2);
- lean_ctor_release(x_1616, 3);
- x_1729 = x_1616;
+if (lean_is_exclusive(x_1702)) {
+ lean_ctor_release(x_1702, 0);
+ lean_ctor_release(x_1702, 1);
+ lean_ctor_release(x_1702, 2);
+ lean_ctor_release(x_1702, 3);
+ x_1729 = x_1702;
 } else {
- lean_dec_ref(x_1616);
+ lean_dec_ref(x_1702);
  x_1729 = lean_box(0);
 }
 if (lean_is_scalar(x_1729)) {
@@ -13434,400 +14491,249 @@ if (lean_is_scalar(x_1729)) {
 } else {
  x_1730 = x_1729;
 }
-lean_ctor_set(x_1730, 0, x_1717);
-lean_ctor_set(x_1730, 1, x_1718);
-lean_ctor_set(x_1730, 2, x_1719);
-lean_ctor_set(x_1730, 3, x_1720);
-lean_ctor_set_uint8(x_1730, sizeof(void*)*4, x_1402);
+lean_ctor_set(x_1730, 0, x_1720);
+lean_ctor_set(x_1730, 1, x_1721);
+lean_ctor_set(x_1730, 2, x_1722);
+lean_ctor_set(x_1730, 3, x_1723);
+lean_ctor_set_uint8(x_1730, sizeof(void*)*4, x_1716);
+x_1731 = 1;
 if (lean_is_scalar(x_1724)) {
- x_1731 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1731 = x_1724;
-}
-lean_ctor_set(x_1731, 0, x_1730);
-lean_ctor_set(x_1731, 1, x_1715);
-lean_ctor_set(x_1731, 2, x_1716);
-lean_ctor_set(x_1731, 3, x_1265);
-lean_ctor_set_uint8(x_1731, sizeof(void*)*4, x_1657);
-if (lean_is_scalar(x_1721)) {
  x_1732 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1732 = x_1721;
+ x_1732 = x_1724;
 }
-lean_ctor_set(x_1732, 0, x_1731);
+lean_ctor_set(x_1732, 0, x_1676);
 lean_ctor_set(x_1732, 1, x_2);
 lean_ctor_set(x_1732, 2, x_3);
-lean_ctor_set(x_1732, 3, x_1275);
-lean_ctor_set_uint8(x_1732, sizeof(void*)*4, x_1402);
-x_1733 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1732, 3, x_1730);
+lean_ctor_set_uint8(x_1732, sizeof(void*)*4, x_1731);
+if (lean_is_scalar(x_1719)) {
+ x_1733 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1733 = x_1719;
+}
 lean_ctor_set(x_1733, 0, x_1725);
 lean_ctor_set(x_1733, 1, x_1726);
 lean_ctor_set(x_1733, 2, x_1727);
 lean_ctor_set(x_1733, 3, x_1728);
-lean_ctor_set_uint8(x_1733, sizeof(void*)*4, x_1402);
-x_1734 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1734, 0, x_1732);
-lean_ctor_set(x_1734, 1, x_1722);
-lean_ctor_set(x_1734, 2, x_1723);
-lean_ctor_set(x_1734, 3, x_1733);
-lean_ctor_set_uint8(x_1734, sizeof(void*)*4, x_1657);
-return x_1734;
+lean_ctor_set_uint8(x_1733, sizeof(void*)*4, x_1731);
+x_1734 = 0;
+x_1735 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1735, 0, x_1732);
+lean_ctor_set(x_1735, 1, x_1717);
+lean_ctor_set(x_1735, 2, x_1718);
+lean_ctor_set(x_1735, 3, x_1733);
+lean_ctor_set_uint8(x_1735, sizeof(void*)*4, x_1734);
+return x_1735;
+}
+else
+{
+lean_object* x_1736; lean_object* x_1737; lean_object* x_1738; lean_object* x_1739; lean_object* x_1740; lean_object* x_1741; lean_object* x_1742; lean_object* x_1743; uint8_t x_1744; lean_object* x_1745; lean_object* x_1746; uint8_t x_1747; lean_object* x_1748; 
+x_1736 = lean_ctor_get(x_4, 1);
+lean_inc(x_1736);
+x_1737 = lean_ctor_get(x_4, 2);
+lean_inc(x_1737);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1738 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1738 = lean_box(0);
+}
+x_1739 = lean_ctor_get(x_1680, 0);
+lean_inc(x_1739);
+x_1740 = lean_ctor_get(x_1680, 1);
+lean_inc(x_1740);
+x_1741 = lean_ctor_get(x_1680, 2);
+lean_inc(x_1741);
+x_1742 = lean_ctor_get(x_1680, 3);
+lean_inc(x_1742);
+if (lean_is_exclusive(x_1680)) {
+ lean_ctor_release(x_1680, 0);
+ lean_ctor_release(x_1680, 1);
+ lean_ctor_release(x_1680, 2);
+ lean_ctor_release(x_1680, 3);
+ x_1743 = x_1680;
+} else {
+ lean_dec_ref(x_1680);
+ x_1743 = lean_box(0);
+}
+x_1744 = 1;
+if (lean_is_scalar(x_1743)) {
+ x_1745 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1745 = x_1743;
+}
+lean_ctor_set(x_1745, 0, x_1676);
+lean_ctor_set(x_1745, 1, x_2);
+lean_ctor_set(x_1745, 2, x_3);
+lean_ctor_set(x_1745, 3, x_1739);
+lean_ctor_set_uint8(x_1745, sizeof(void*)*4, x_1744);
+if (lean_is_scalar(x_1738)) {
+ x_1746 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1746 = x_1738;
+}
+lean_ctor_set(x_1746, 0, x_1742);
+lean_ctor_set(x_1746, 1, x_1736);
+lean_ctor_set(x_1746, 2, x_1737);
+lean_ctor_set(x_1746, 3, x_1702);
+lean_ctor_set_uint8(x_1746, sizeof(void*)*4, x_1744);
+x_1747 = 0;
+x_1748 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1748, 0, x_1745);
+lean_ctor_set(x_1748, 1, x_1740);
+lean_ctor_set(x_1748, 2, x_1741);
+lean_ctor_set(x_1748, 3, x_1746);
+lean_ctor_set_uint8(x_1748, sizeof(void*)*4, x_1747);
+return x_1748;
+}
 }
 }
 else
 {
-uint8_t x_1735; 
-x_1735 = !lean_is_exclusive(x_1);
-if (x_1735 == 0)
+lean_object* x_1749; 
+x_1749 = lean_ctor_get(x_4, 3);
+lean_inc(x_1749);
+if (lean_obj_tag(x_1749) == 0)
 {
-lean_object* x_1736; lean_object* x_1737; lean_object* x_1738; lean_object* x_1739; uint8_t x_1740; 
-x_1736 = lean_ctor_get(x_1, 1);
-x_1737 = lean_ctor_get(x_1, 2);
-x_1738 = lean_ctor_get(x_1, 3);
-lean_dec(x_1738);
-x_1739 = lean_ctor_get(x_1, 0);
-lean_dec(x_1739);
-x_1740 = !lean_is_exclusive(x_234);
-if (x_1740 == 0)
-{
-uint8_t x_1741; 
-x_1741 = !lean_is_exclusive(x_4);
-if (x_1741 == 0)
-{
-lean_object* x_1742; lean_object* x_1743; lean_object* x_1744; lean_object* x_1745; lean_object* x_1746; lean_object* x_1747; lean_object* x_1748; lean_object* x_1749; uint8_t x_1750; 
-x_1742 = lean_ctor_get(x_234, 0);
-x_1743 = lean_ctor_get(x_234, 1);
-x_1744 = lean_ctor_get(x_234, 2);
-x_1745 = lean_ctor_get(x_234, 3);
-x_1746 = lean_ctor_get(x_4, 1);
-x_1747 = lean_ctor_get(x_4, 2);
-x_1748 = lean_ctor_get(x_4, 3);
-lean_dec(x_1748);
-x_1749 = lean_ctor_get(x_4, 0);
-lean_dec(x_1749);
-x_1750 = !lean_is_exclusive(x_1275);
-if (x_1750 == 0)
-{
-lean_object* x_1751; lean_object* x_1752; lean_object* x_1753; lean_object* x_1754; lean_object* x_1755; 
-x_1751 = lean_ctor_get(x_1275, 0);
-x_1752 = lean_ctor_get(x_1275, 1);
-x_1753 = lean_ctor_get(x_1275, 2);
-x_1754 = lean_ctor_get(x_1275, 3);
-lean_ctor_set(x_1275, 3, x_1745);
-lean_ctor_set(x_1275, 2, x_1744);
-lean_ctor_set(x_1275, 1, x_1743);
-lean_ctor_set(x_1275, 0, x_1742);
-lean_ctor_set_uint8(x_1275, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1737);
-lean_ctor_set(x_4, 1, x_1736);
-lean_ctor_set(x_234, 3, x_1754);
-lean_ctor_set(x_234, 2, x_1753);
-lean_ctor_set(x_234, 1, x_1752);
-lean_ctor_set(x_234, 0, x_1751);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_1, 3, x_1616);
-lean_ctor_set(x_1, 2, x_1747);
-lean_ctor_set(x_1, 1, x_1746);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1274);
-x_1755 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1755, 0, x_4);
-lean_ctor_set(x_1755, 1, x_2);
-lean_ctor_set(x_1755, 2, x_3);
-lean_ctor_set(x_1755, 3, x_1);
-lean_ctor_set_uint8(x_1755, sizeof(void*)*4, x_1657);
-return x_1755;
+lean_object* x_1750; uint8_t x_1751; lean_object* x_1752; 
+if (lean_is_exclusive(x_1680)) {
+ lean_ctor_release(x_1680, 0);
+ lean_ctor_release(x_1680, 1);
+ lean_ctor_release(x_1680, 2);
+ lean_ctor_release(x_1680, 3);
+ x_1750 = x_1680;
+} else {
+ lean_dec_ref(x_1680);
+ x_1750 = lean_box(0);
+}
+x_1751 = 1;
+if (lean_is_scalar(x_1750)) {
+ x_1752 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1752 = x_1750;
+}
+lean_ctor_set(x_1752, 0, x_1676);
+lean_ctor_set(x_1752, 1, x_2);
+lean_ctor_set(x_1752, 2, x_3);
+lean_ctor_set(x_1752, 3, x_4);
+lean_ctor_set_uint8(x_1752, sizeof(void*)*4, x_1751);
+return x_1752;
 }
 else
 {
-lean_object* x_1756; lean_object* x_1757; lean_object* x_1758; lean_object* x_1759; lean_object* x_1760; lean_object* x_1761; 
-x_1756 = lean_ctor_get(x_1275, 0);
-x_1757 = lean_ctor_get(x_1275, 1);
-x_1758 = lean_ctor_get(x_1275, 2);
-x_1759 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1759);
-lean_inc(x_1758);
+uint8_t x_1753; 
+x_1753 = lean_ctor_get_uint8(x_1749, sizeof(void*)*4);
+if (x_1753 == 0)
+{
+lean_object* x_1754; lean_object* x_1755; lean_object* x_1756; lean_object* x_1757; lean_object* x_1758; lean_object* x_1759; lean_object* x_1760; lean_object* x_1761; uint8_t x_1762; lean_object* x_1763; lean_object* x_1764; lean_object* x_1765; uint8_t x_1766; lean_object* x_1767; 
+x_1754 = lean_ctor_get(x_4, 1);
+lean_inc(x_1754);
+x_1755 = lean_ctor_get(x_4, 2);
+lean_inc(x_1755);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_1756 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_1756 = lean_box(0);
+}
+x_1757 = lean_ctor_get(x_1749, 0);
 lean_inc(x_1757);
-lean_inc(x_1756);
-lean_dec(x_1275);
-x_1760 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1760, 0, x_1742);
-lean_ctor_set(x_1760, 1, x_1743);
-lean_ctor_set(x_1760, 2, x_1744);
-lean_ctor_set(x_1760, 3, x_1745);
-lean_ctor_set_uint8(x_1760, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1737);
-lean_ctor_set(x_4, 1, x_1736);
-lean_ctor_set(x_4, 0, x_1760);
-lean_ctor_set(x_234, 3, x_1759);
-lean_ctor_set(x_234, 2, x_1758);
-lean_ctor_set(x_234, 1, x_1757);
-lean_ctor_set(x_234, 0, x_1756);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_1, 3, x_1616);
-lean_ctor_set(x_1, 2, x_1747);
-lean_ctor_set(x_1, 1, x_1746);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1274);
-x_1761 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1761, 0, x_4);
-lean_ctor_set(x_1761, 1, x_2);
-lean_ctor_set(x_1761, 2, x_3);
-lean_ctor_set(x_1761, 3, x_1);
-lean_ctor_set_uint8(x_1761, sizeof(void*)*4, x_1657);
-return x_1761;
+x_1758 = lean_ctor_get(x_1749, 1);
+lean_inc(x_1758);
+x_1759 = lean_ctor_get(x_1749, 2);
+lean_inc(x_1759);
+x_1760 = lean_ctor_get(x_1749, 3);
+lean_inc(x_1760);
+if (lean_is_exclusive(x_1749)) {
+ lean_ctor_release(x_1749, 0);
+ lean_ctor_release(x_1749, 1);
+ lean_ctor_release(x_1749, 2);
+ lean_ctor_release(x_1749, 3);
+ x_1761 = x_1749;
+} else {
+ lean_dec_ref(x_1749);
+ x_1761 = lean_box(0);
 }
+x_1762 = 1;
+lean_inc(x_1680);
+if (lean_is_scalar(x_1761)) {
+ x_1763 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1763 = x_1761;
+}
+lean_ctor_set(x_1763, 0, x_1676);
+lean_ctor_set(x_1763, 1, x_2);
+lean_ctor_set(x_1763, 2, x_3);
+lean_ctor_set(x_1763, 3, x_1680);
+if (lean_is_exclusive(x_1680)) {
+ lean_ctor_release(x_1680, 0);
+ lean_ctor_release(x_1680, 1);
+ lean_ctor_release(x_1680, 2);
+ lean_ctor_release(x_1680, 3);
+ x_1764 = x_1680;
+} else {
+ lean_dec_ref(x_1680);
+ x_1764 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1763, sizeof(void*)*4, x_1762);
+if (lean_is_scalar(x_1764)) {
+ x_1765 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1765 = x_1764;
+}
+lean_ctor_set(x_1765, 0, x_1757);
+lean_ctor_set(x_1765, 1, x_1758);
+lean_ctor_set(x_1765, 2, x_1759);
+lean_ctor_set(x_1765, 3, x_1760);
+lean_ctor_set_uint8(x_1765, sizeof(void*)*4, x_1762);
+x_1766 = 0;
+if (lean_is_scalar(x_1756)) {
+ x_1767 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1767 = x_1756;
+}
+lean_ctor_set(x_1767, 0, x_1763);
+lean_ctor_set(x_1767, 1, x_1754);
+lean_ctor_set(x_1767, 2, x_1755);
+lean_ctor_set(x_1767, 3, x_1765);
+lean_ctor_set_uint8(x_1767, sizeof(void*)*4, x_1766);
+return x_1767;
 }
 else
 {
-lean_object* x_1762; lean_object* x_1763; lean_object* x_1764; lean_object* x_1765; lean_object* x_1766; lean_object* x_1767; lean_object* x_1768; lean_object* x_1769; lean_object* x_1770; lean_object* x_1771; lean_object* x_1772; lean_object* x_1773; lean_object* x_1774; lean_object* x_1775; 
-x_1762 = lean_ctor_get(x_234, 0);
-x_1763 = lean_ctor_get(x_234, 1);
-x_1764 = lean_ctor_get(x_234, 2);
-x_1765 = lean_ctor_get(x_234, 3);
-x_1766 = lean_ctor_get(x_4, 1);
-x_1767 = lean_ctor_get(x_4, 2);
-lean_inc(x_1767);
-lean_inc(x_1766);
-lean_dec(x_4);
-x_1768 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1768);
-x_1769 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1769);
-x_1770 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1770);
-x_1771 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1771);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1772 = x_1275;
+lean_object* x_1768; uint8_t x_1769; lean_object* x_1770; 
+lean_dec(x_1680);
+if (lean_is_exclusive(x_1749)) {
+ lean_ctor_release(x_1749, 0);
+ lean_ctor_release(x_1749, 1);
+ lean_ctor_release(x_1749, 2);
+ lean_ctor_release(x_1749, 3);
+ x_1768 = x_1749;
 } else {
- lean_dec_ref(x_1275);
- x_1772 = lean_box(0);
+ lean_dec_ref(x_1749);
+ x_1768 = lean_box(0);
 }
-if (lean_is_scalar(x_1772)) {
- x_1773 = lean_alloc_ctor(1, 4, 1);
+x_1769 = 1;
+if (lean_is_scalar(x_1768)) {
+ x_1770 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1773 = x_1772;
-}
-lean_ctor_set(x_1773, 0, x_1762);
-lean_ctor_set(x_1773, 1, x_1763);
-lean_ctor_set(x_1773, 2, x_1764);
-lean_ctor_set(x_1773, 3, x_1765);
-lean_ctor_set_uint8(x_1773, sizeof(void*)*4, x_1657);
-x_1774 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1774, 0, x_1773);
-lean_ctor_set(x_1774, 1, x_1736);
-lean_ctor_set(x_1774, 2, x_1737);
-lean_ctor_set(x_1774, 3, x_1265);
-lean_ctor_set_uint8(x_1774, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_234, 3, x_1771);
-lean_ctor_set(x_234, 2, x_1770);
-lean_ctor_set(x_234, 1, x_1769);
-lean_ctor_set(x_234, 0, x_1768);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_1, 3, x_1616);
-lean_ctor_set(x_1, 2, x_1767);
-lean_ctor_set(x_1, 1, x_1766);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1274);
-x_1775 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1775, 0, x_1774);
-lean_ctor_set(x_1775, 1, x_2);
-lean_ctor_set(x_1775, 2, x_3);
-lean_ctor_set(x_1775, 3, x_1);
-lean_ctor_set_uint8(x_1775, sizeof(void*)*4, x_1657);
-return x_1775;
-}
-}
-else
-{
-lean_object* x_1776; lean_object* x_1777; lean_object* x_1778; lean_object* x_1779; lean_object* x_1780; lean_object* x_1781; lean_object* x_1782; lean_object* x_1783; lean_object* x_1784; lean_object* x_1785; lean_object* x_1786; lean_object* x_1787; lean_object* x_1788; lean_object* x_1789; lean_object* x_1790; lean_object* x_1791; 
-x_1776 = lean_ctor_get(x_234, 0);
-x_1777 = lean_ctor_get(x_234, 1);
-x_1778 = lean_ctor_get(x_234, 2);
-x_1779 = lean_ctor_get(x_234, 3);
-lean_inc(x_1779);
-lean_inc(x_1778);
-lean_inc(x_1777);
-lean_inc(x_1776);
-lean_dec(x_234);
-x_1780 = lean_ctor_get(x_4, 1);
-lean_inc(x_1780);
-x_1781 = lean_ctor_get(x_4, 2);
-lean_inc(x_1781);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1782 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1782 = lean_box(0);
-}
-x_1783 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1783);
-x_1784 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1784);
-x_1785 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1785);
-x_1786 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1786);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1787 = x_1275;
-} else {
- lean_dec_ref(x_1275);
- x_1787 = lean_box(0);
-}
-if (lean_is_scalar(x_1787)) {
- x_1788 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1788 = x_1787;
-}
-lean_ctor_set(x_1788, 0, x_1776);
-lean_ctor_set(x_1788, 1, x_1777);
-lean_ctor_set(x_1788, 2, x_1778);
-lean_ctor_set(x_1788, 3, x_1779);
-lean_ctor_set_uint8(x_1788, sizeof(void*)*4, x_1657);
-if (lean_is_scalar(x_1782)) {
- x_1789 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1789 = x_1782;
-}
-lean_ctor_set(x_1789, 0, x_1788);
-lean_ctor_set(x_1789, 1, x_1736);
-lean_ctor_set(x_1789, 2, x_1737);
-lean_ctor_set(x_1789, 3, x_1265);
-lean_ctor_set_uint8(x_1789, sizeof(void*)*4, x_1274);
-x_1790 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1790, 0, x_1783);
-lean_ctor_set(x_1790, 1, x_1784);
-lean_ctor_set(x_1790, 2, x_1785);
-lean_ctor_set(x_1790, 3, x_1786);
-lean_ctor_set_uint8(x_1790, sizeof(void*)*4, x_1657);
-lean_ctor_set(x_1, 3, x_1616);
-lean_ctor_set(x_1, 2, x_1781);
-lean_ctor_set(x_1, 1, x_1780);
-lean_ctor_set(x_1, 0, x_1790);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1274);
-x_1791 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1791, 0, x_1789);
-lean_ctor_set(x_1791, 1, x_2);
-lean_ctor_set(x_1791, 2, x_3);
-lean_ctor_set(x_1791, 3, x_1);
-lean_ctor_set_uint8(x_1791, sizeof(void*)*4, x_1657);
-return x_1791;
-}
-}
-else
-{
-lean_object* x_1792; lean_object* x_1793; lean_object* x_1794; lean_object* x_1795; lean_object* x_1796; lean_object* x_1797; lean_object* x_1798; lean_object* x_1799; lean_object* x_1800; lean_object* x_1801; lean_object* x_1802; lean_object* x_1803; lean_object* x_1804; lean_object* x_1805; lean_object* x_1806; lean_object* x_1807; lean_object* x_1808; lean_object* x_1809; lean_object* x_1810; lean_object* x_1811; 
-x_1792 = lean_ctor_get(x_1, 1);
-x_1793 = lean_ctor_get(x_1, 2);
-lean_inc(x_1793);
-lean_inc(x_1792);
-lean_dec(x_1);
-x_1794 = lean_ctor_get(x_234, 0);
-lean_inc(x_1794);
-x_1795 = lean_ctor_get(x_234, 1);
-lean_inc(x_1795);
-x_1796 = lean_ctor_get(x_234, 2);
-lean_inc(x_1796);
-x_1797 = lean_ctor_get(x_234, 3);
-lean_inc(x_1797);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1798 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1798 = lean_box(0);
-}
-x_1799 = lean_ctor_get(x_4, 1);
-lean_inc(x_1799);
-x_1800 = lean_ctor_get(x_4, 2);
-lean_inc(x_1800);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1801 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1801 = lean_box(0);
-}
-x_1802 = lean_ctor_get(x_1275, 0);
-lean_inc(x_1802);
-x_1803 = lean_ctor_get(x_1275, 1);
-lean_inc(x_1803);
-x_1804 = lean_ctor_get(x_1275, 2);
-lean_inc(x_1804);
-x_1805 = lean_ctor_get(x_1275, 3);
-lean_inc(x_1805);
-if (lean_is_exclusive(x_1275)) {
- lean_ctor_release(x_1275, 0);
- lean_ctor_release(x_1275, 1);
- lean_ctor_release(x_1275, 2);
- lean_ctor_release(x_1275, 3);
- x_1806 = x_1275;
-} else {
- lean_dec_ref(x_1275);
- x_1806 = lean_box(0);
-}
-if (lean_is_scalar(x_1806)) {
- x_1807 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1807 = x_1806;
-}
-lean_ctor_set(x_1807, 0, x_1794);
-lean_ctor_set(x_1807, 1, x_1795);
-lean_ctor_set(x_1807, 2, x_1796);
-lean_ctor_set(x_1807, 3, x_1797);
-lean_ctor_set_uint8(x_1807, sizeof(void*)*4, x_1657);
-if (lean_is_scalar(x_1801)) {
- x_1808 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1808 = x_1801;
-}
-lean_ctor_set(x_1808, 0, x_1807);
-lean_ctor_set(x_1808, 1, x_1792);
-lean_ctor_set(x_1808, 2, x_1793);
-lean_ctor_set(x_1808, 3, x_1265);
-lean_ctor_set_uint8(x_1808, sizeof(void*)*4, x_1274);
-if (lean_is_scalar(x_1798)) {
- x_1809 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1809 = x_1798;
-}
-lean_ctor_set(x_1809, 0, x_1802);
-lean_ctor_set(x_1809, 1, x_1803);
-lean_ctor_set(x_1809, 2, x_1804);
-lean_ctor_set(x_1809, 3, x_1805);
-lean_ctor_set_uint8(x_1809, sizeof(void*)*4, x_1657);
-x_1810 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1810, 0, x_1809);
-lean_ctor_set(x_1810, 1, x_1799);
-lean_ctor_set(x_1810, 2, x_1800);
-lean_ctor_set(x_1810, 3, x_1616);
-lean_ctor_set_uint8(x_1810, sizeof(void*)*4, x_1274);
-x_1811 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1811, 0, x_1808);
-lean_ctor_set(x_1811, 1, x_2);
-lean_ctor_set(x_1811, 2, x_3);
-lean_ctor_set(x_1811, 3, x_1810);
-lean_ctor_set_uint8(x_1811, sizeof(void*)*4, x_1657);
-return x_1811;
+ x_1770 = x_1768;
 }
+lean_ctor_set(x_1770, 0, x_1676);
+lean_ctor_set(x_1770, 1, x_2);
+lean_ctor_set(x_1770, 2, x_3);
+lean_ctor_set(x_1770, 3, x_4);
+lean_ctor_set_uint8(x_1770, sizeof(void*)*4, x_1769);
+return x_1770;
 }
 }
 }
@@ -13835,599 +14741,750 @@ return x_1811;
 }
 else
 {
-uint8_t x_1812; 
-x_1812 = !lean_is_exclusive(x_1);
-if (x_1812 == 0)
-{
-lean_object* x_1813; lean_object* x_1814; uint8_t x_1815; 
-x_1813 = lean_ctor_get(x_1, 3);
-lean_dec(x_1813);
-x_1814 = lean_ctor_get(x_1, 0);
-lean_dec(x_1814);
-x_1815 = !lean_is_exclusive(x_234);
-if (x_1815 == 0)
-{
-lean_object* x_1816; 
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1274);
-x_1816 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1816, 0, x_1);
-lean_ctor_set(x_1816, 1, x_2);
-lean_ctor_set(x_1816, 2, x_3);
-lean_ctor_set(x_1816, 3, x_4);
-lean_ctor_set_uint8(x_1816, sizeof(void*)*4, x_1274);
-return x_1816;
-}
-else
-{
-lean_object* x_1817; lean_object* x_1818; lean_object* x_1819; lean_object* x_1820; lean_object* x_1821; lean_object* x_1822; 
-x_1817 = lean_ctor_get(x_234, 0);
-x_1818 = lean_ctor_get(x_234, 1);
-x_1819 = lean_ctor_get(x_234, 2);
-x_1820 = lean_ctor_get(x_234, 3);
-lean_inc(x_1820);
-lean_inc(x_1819);
-lean_inc(x_1818);
-lean_inc(x_1817);
-lean_dec(x_234);
-x_1821 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1821, 0, x_1817);
-lean_ctor_set(x_1821, 1, x_1818);
-lean_ctor_set(x_1821, 2, x_1819);
-lean_ctor_set(x_1821, 3, x_1820);
-lean_ctor_set_uint8(x_1821, sizeof(void*)*4, x_1274);
-lean_ctor_set(x_1, 0, x_1821);
-x_1822 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1822, 0, x_1);
-lean_ctor_set(x_1822, 1, x_2);
-lean_ctor_set(x_1822, 2, x_3);
-lean_ctor_set(x_1822, 3, x_4);
-lean_ctor_set_uint8(x_1822, sizeof(void*)*4, x_1274);
-return x_1822;
-}
-}
-else
-{
-lean_object* x_1823; lean_object* x_1824; lean_object* x_1825; lean_object* x_1826; lean_object* x_1827; lean_object* x_1828; lean_object* x_1829; lean_object* x_1830; lean_object* x_1831; lean_object* x_1832; 
-x_1823 = lean_ctor_get(x_1, 1);
-x_1824 = lean_ctor_get(x_1, 2);
-lean_inc(x_1824);
-lean_inc(x_1823);
-lean_dec(x_1);
-x_1825 = lean_ctor_get(x_234, 0);
-lean_inc(x_1825);
-x_1826 = lean_ctor_get(x_234, 1);
-lean_inc(x_1826);
-x_1827 = lean_ctor_get(x_234, 2);
-lean_inc(x_1827);
-x_1828 = lean_ctor_get(x_234, 3);
-lean_inc(x_1828);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1829 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1829 = lean_box(0);
-}
-if (lean_is_scalar(x_1829)) {
- x_1830 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1830 = x_1829;
-}
-lean_ctor_set(x_1830, 0, x_1825);
-lean_ctor_set(x_1830, 1, x_1826);
-lean_ctor_set(x_1830, 2, x_1827);
-lean_ctor_set(x_1830, 3, x_1828);
-lean_ctor_set_uint8(x_1830, sizeof(void*)*4, x_1274);
-x_1831 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1831, 0, x_1830);
-lean_ctor_set(x_1831, 1, x_1823);
-lean_ctor_set(x_1831, 2, x_1824);
-lean_ctor_set(x_1831, 3, x_1265);
-lean_ctor_set_uint8(x_1831, sizeof(void*)*4, x_233);
-x_1832 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1832, 0, x_1831);
-lean_ctor_set(x_1832, 1, x_2);
-lean_ctor_set(x_1832, 2, x_3);
-lean_ctor_set(x_1832, 3, x_4);
-lean_ctor_set_uint8(x_1832, sizeof(void*)*4, x_1274);
-return x_1832;
+uint8_t x_1771; lean_object* x_1772; 
+x_1771 = 1;
+x_1772 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1772, 0, x_1676);
+lean_ctor_set(x_1772, 1, x_2);
+lean_ctor_set(x_1772, 2, x_3);
+lean_ctor_set(x_1772, 3, x_4);
+lean_ctor_set_uint8(x_1772, sizeof(void*)*4, x_1771);
+return x_1772;
 }
 }
 }
 }
-else
-{
-uint8_t x_1833; 
-x_1833 = lean_ctor_get_uint8(x_1265, sizeof(void*)*4);
-if (x_1833 == 0)
-{
-uint8_t x_1834; 
-x_1834 = !lean_is_exclusive(x_1);
-if (x_1834 == 0)
-{
-lean_object* x_1835; lean_object* x_1836; lean_object* x_1837; lean_object* x_1838; uint8_t x_1839; 
-x_1835 = lean_ctor_get(x_1, 1);
-x_1836 = lean_ctor_get(x_1, 2);
-x_1837 = lean_ctor_get(x_1, 3);
-lean_dec(x_1837);
-x_1838 = lean_ctor_get(x_1, 0);
-lean_dec(x_1838);
-x_1839 = !lean_is_exclusive(x_1265);
-if (x_1839 == 0)
-{
-lean_object* x_1840; lean_object* x_1841; lean_object* x_1842; lean_object* x_1843; uint8_t x_1844; 
-x_1840 = lean_ctor_get(x_1265, 0);
-x_1841 = lean_ctor_get(x_1265, 1);
-x_1842 = lean_ctor_get(x_1265, 2);
-x_1843 = lean_ctor_get(x_1265, 3);
-lean_inc(x_234);
-lean_ctor_set(x_1265, 3, x_1840);
-lean_ctor_set(x_1265, 2, x_1836);
-lean_ctor_set(x_1265, 1, x_1835);
-lean_ctor_set(x_1265, 0, x_234);
-x_1844 = !lean_is_exclusive(x_234);
-if (x_1844 == 0)
-{
-lean_object* x_1845; lean_object* x_1846; lean_object* x_1847; lean_object* x_1848; 
-x_1845 = lean_ctor_get(x_234, 3);
-lean_dec(x_1845);
-x_1846 = lean_ctor_get(x_234, 2);
-lean_dec(x_1846);
-x_1847 = lean_ctor_get(x_234, 1);
-lean_dec(x_1847);
-x_1848 = lean_ctor_get(x_234, 0);
-lean_dec(x_1848);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_234, 3, x_4);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1843);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1842);
-lean_ctor_set(x_1, 1, x_1841);
-lean_ctor_set(x_1, 0, x_1265);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1833);
-return x_1;
-}
-else
-{
-lean_object* x_1849; 
-lean_dec(x_234);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1237);
-x_1849 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1849, 0, x_1843);
-lean_ctor_set(x_1849, 1, x_2);
-lean_ctor_set(x_1849, 2, x_3);
-lean_ctor_set(x_1849, 3, x_4);
-lean_ctor_set_uint8(x_1849, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1849);
-lean_ctor_set(x_1, 2, x_1842);
-lean_ctor_set(x_1, 1, x_1841);
-lean_ctor_set(x_1, 0, x_1265);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1833);
-return x_1;
 }
 }
-else
-{
-lean_object* x_1850; lean_object* x_1851; lean_object* x_1852; lean_object* x_1853; lean_object* x_1854; lean_object* x_1855; lean_object* x_1856; 
-x_1850 = lean_ctor_get(x_1265, 0);
-x_1851 = lean_ctor_get(x_1265, 1);
-x_1852 = lean_ctor_get(x_1265, 2);
-x_1853 = lean_ctor_get(x_1265, 3);
-lean_inc(x_1853);
-lean_inc(x_1852);
-lean_inc(x_1851);
-lean_inc(x_1850);
-lean_dec(x_1265);
-lean_inc(x_234);
-x_1854 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1854, 0, x_234);
-lean_ctor_set(x_1854, 1, x_1835);
-lean_ctor_set(x_1854, 2, x_1836);
-lean_ctor_set(x_1854, 3, x_1850);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1855 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1855 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1854, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1855)) {
- x_1856 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1856 = x_1855;
-}
-lean_ctor_set(x_1856, 0, x_1853);
-lean_ctor_set(x_1856, 1, x_2);
-lean_ctor_set(x_1856, 2, x_3);
-lean_ctor_set(x_1856, 3, x_4);
-lean_ctor_set_uint8(x_1856, sizeof(void*)*4, x_1237);
-lean_ctor_set(x_1, 3, x_1856);
-lean_ctor_set(x_1, 2, x_1852);
-lean_ctor_set(x_1, 1, x_1851);
-lean_ctor_set(x_1, 0, x_1854);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1833);
-return x_1;
-}
-}
-else
-{
-lean_object* x_1857; lean_object* x_1858; lean_object* x_1859; lean_object* x_1860; lean_object* x_1861; lean_object* x_1862; lean_object* x_1863; lean_object* x_1864; lean_object* x_1865; lean_object* x_1866; lean_object* x_1867; 
-x_1857 = lean_ctor_get(x_1, 1);
-x_1858 = lean_ctor_get(x_1, 2);
-lean_inc(x_1858);
-lean_inc(x_1857);
-lean_dec(x_1);
-x_1859 = lean_ctor_get(x_1265, 0);
-lean_inc(x_1859);
-x_1860 = lean_ctor_get(x_1265, 1);
-lean_inc(x_1860);
-x_1861 = lean_ctor_get(x_1265, 2);
-lean_inc(x_1861);
-x_1862 = lean_ctor_get(x_1265, 3);
-lean_inc(x_1862);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_1863 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_1863 = lean_box(0);
-}
-lean_inc(x_234);
-if (lean_is_scalar(x_1863)) {
- x_1864 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1864 = x_1863;
-}
-lean_ctor_set(x_1864, 0, x_234);
-lean_ctor_set(x_1864, 1, x_1857);
-lean_ctor_set(x_1864, 2, x_1858);
-lean_ctor_set(x_1864, 3, x_1859);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1865 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1865 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1864, sizeof(void*)*4, x_1237);
-if (lean_is_scalar(x_1865)) {
- x_1866 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1866 = x_1865;
-}
-lean_ctor_set(x_1866, 0, x_1862);
-lean_ctor_set(x_1866, 1, x_2);
-lean_ctor_set(x_1866, 2, x_3);
-lean_ctor_set(x_1866, 3, x_4);
-lean_ctor_set_uint8(x_1866, sizeof(void*)*4, x_1237);
-x_1867 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1867, 0, x_1864);
-lean_ctor_set(x_1867, 1, x_1860);
-lean_ctor_set(x_1867, 2, x_1861);
-lean_ctor_set(x_1867, 3, x_1866);
-lean_ctor_set_uint8(x_1867, sizeof(void*)*4, x_1833);
-return x_1867;
 }
 }
 else
 {
 if (lean_obj_tag(x_4) == 0)
 {
-uint8_t x_1868; 
-x_1868 = !lean_is_exclusive(x_1);
-if (x_1868 == 0)
+uint8_t x_1773; lean_object* x_1774; 
+x_1773 = 1;
+x_1774 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1774, 0, x_1);
+lean_ctor_set(x_1774, 1, x_2);
+lean_ctor_set(x_1774, 2, x_3);
+lean_ctor_set(x_1774, 3, x_4);
+lean_ctor_set_uint8(x_1774, sizeof(void*)*4, x_1773);
+return x_1774;
+}
+else
 {
-lean_object* x_1869; lean_object* x_1870; uint8_t x_1871; 
-x_1869 = lean_ctor_get(x_1, 3);
-lean_dec(x_1869);
-x_1870 = lean_ctor_get(x_1, 0);
-lean_dec(x_1870);
-x_1871 = !lean_is_exclusive(x_234);
+uint8_t x_1775; 
+x_1775 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_1775 == 0)
+{
+lean_object* x_1776; 
+x_1776 = lean_ctor_get(x_4, 0);
+lean_inc(x_1776);
+if (lean_obj_tag(x_1776) == 0)
+{
+lean_object* x_1777; 
+x_1777 = lean_ctor_get(x_4, 3);
+lean_inc(x_1777);
+if (lean_obj_tag(x_1777) == 0)
+{
+uint8_t x_1778; lean_object* x_1779; 
+x_1778 = 1;
+x_1779 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1779, 0, x_1);
+lean_ctor_set(x_1779, 1, x_2);
+lean_ctor_set(x_1779, 2, x_3);
+lean_ctor_set(x_1779, 3, x_4);
+lean_ctor_set_uint8(x_1779, sizeof(void*)*4, x_1778);
+return x_1779;
+}
+else
+{
+uint8_t x_1780; 
+x_1780 = lean_ctor_get_uint8(x_1777, sizeof(void*)*4);
+if (x_1780 == 0)
+{
+uint8_t x_1781; 
+x_1781 = !lean_is_exclusive(x_4);
+if (x_1781 == 0)
+{
+lean_object* x_1782; lean_object* x_1783; lean_object* x_1784; lean_object* x_1785; uint8_t x_1786; 
+x_1782 = lean_ctor_get(x_4, 1);
+x_1783 = lean_ctor_get(x_4, 2);
+x_1784 = lean_ctor_get(x_4, 3);
+lean_dec(x_1784);
+x_1785 = lean_ctor_get(x_4, 0);
+lean_dec(x_1785);
+x_1786 = !lean_is_exclusive(x_1777);
+if (x_1786 == 0)
+{
+lean_object* x_1787; lean_object* x_1788; lean_object* x_1789; lean_object* x_1790; uint8_t x_1791; uint8_t x_1792; 
+x_1787 = lean_ctor_get(x_1777, 0);
+x_1788 = lean_ctor_get(x_1777, 1);
+x_1789 = lean_ctor_get(x_1777, 2);
+x_1790 = lean_ctor_get(x_1777, 3);
+x_1791 = 1;
+lean_inc(x_1);
+lean_ctor_set(x_1777, 3, x_1776);
+lean_ctor_set(x_1777, 2, x_3);
+lean_ctor_set(x_1777, 1, x_2);
+lean_ctor_set(x_1777, 0, x_1);
+x_1792 = !lean_is_exclusive(x_1);
+if (x_1792 == 0)
+{
+lean_object* x_1793; lean_object* x_1794; lean_object* x_1795; lean_object* x_1796; uint8_t x_1797; 
+x_1793 = lean_ctor_get(x_1, 3);
+lean_dec(x_1793);
+x_1794 = lean_ctor_get(x_1, 2);
+lean_dec(x_1794);
+x_1795 = lean_ctor_get(x_1, 1);
+lean_dec(x_1795);
+x_1796 = lean_ctor_get(x_1, 0);
+lean_dec(x_1796);
+lean_ctor_set_uint8(x_1777, sizeof(void*)*4, x_1791);
+lean_ctor_set(x_4, 3, x_1790);
+lean_ctor_set(x_4, 2, x_1789);
+lean_ctor_set(x_4, 1, x_1788);
+lean_ctor_set(x_4, 0, x_1787);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1791);
+x_1797 = 0;
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_1783);
+lean_ctor_set(x_1, 1, x_1782);
+lean_ctor_set(x_1, 0, x_1777);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1797);
+return x_1;
+}
+else
+{
+uint8_t x_1798; lean_object* x_1799; 
+lean_dec(x_1);
+lean_ctor_set_uint8(x_1777, sizeof(void*)*4, x_1791);
+lean_ctor_set(x_4, 3, x_1790);
+lean_ctor_set(x_4, 2, x_1789);
+lean_ctor_set(x_4, 1, x_1788);
+lean_ctor_set(x_4, 0, x_1787);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1791);
+x_1798 = 0;
+x_1799 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1799, 0, x_1777);
+lean_ctor_set(x_1799, 1, x_1782);
+lean_ctor_set(x_1799, 2, x_1783);
+lean_ctor_set(x_1799, 3, x_4);
+lean_ctor_set_uint8(x_1799, sizeof(void*)*4, x_1798);
+return x_1799;
+}
+}
+else
+{
+lean_object* x_1800; lean_object* x_1801; lean_object* x_1802; lean_object* x_1803; uint8_t x_1804; lean_object* x_1805; lean_object* x_1806; uint8_t x_1807; lean_object* x_1808; 
+x_1800 = lean_ctor_get(x_1777, 0);
+x_1801 = lean_ctor_get(x_1777, 1);
+x_1802 = lean_ctor_get(x_1777, 2);
+x_1803 = lean_ctor_get(x_1777, 3);
+lean_inc(x_1803);
+lean_inc(x_1802);
+lean_inc(x_1801);
+lean_inc(x_1800);
+lean_dec(x_1777);
+x_1804 = 1;
+lean_inc(x_1);
+x_1805 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1805, 0, x_1);
+lean_ctor_set(x_1805, 1, x_2);
+lean_ctor_set(x_1805, 2, x_3);
+lean_ctor_set(x_1805, 3, x_1776);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1806 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1806 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1805, sizeof(void*)*4, x_1804);
+lean_ctor_set(x_4, 3, x_1803);
+lean_ctor_set(x_4, 2, x_1802);
+lean_ctor_set(x_4, 1, x_1801);
+lean_ctor_set(x_4, 0, x_1800);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1804);
+x_1807 = 0;
+if (lean_is_scalar(x_1806)) {
+ x_1808 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1808 = x_1806;
+}
+lean_ctor_set(x_1808, 0, x_1805);
+lean_ctor_set(x_1808, 1, x_1782);
+lean_ctor_set(x_1808, 2, x_1783);
+lean_ctor_set(x_1808, 3, x_4);
+lean_ctor_set_uint8(x_1808, sizeof(void*)*4, x_1807);
+return x_1808;
+}
+}
+else
+{
+lean_object* x_1809; lean_object* x_1810; lean_object* x_1811; lean_object* x_1812; lean_object* x_1813; lean_object* x_1814; lean_object* x_1815; uint8_t x_1816; lean_object* x_1817; lean_object* x_1818; lean_object* x_1819; uint8_t x_1820; lean_object* x_1821; 
+x_1809 = lean_ctor_get(x_4, 1);
+x_1810 = lean_ctor_get(x_4, 2);
+lean_inc(x_1810);
+lean_inc(x_1809);
+lean_dec(x_4);
+x_1811 = lean_ctor_get(x_1777, 0);
+lean_inc(x_1811);
+x_1812 = lean_ctor_get(x_1777, 1);
+lean_inc(x_1812);
+x_1813 = lean_ctor_get(x_1777, 2);
+lean_inc(x_1813);
+x_1814 = lean_ctor_get(x_1777, 3);
+lean_inc(x_1814);
+if (lean_is_exclusive(x_1777)) {
+ lean_ctor_release(x_1777, 0);
+ lean_ctor_release(x_1777, 1);
+ lean_ctor_release(x_1777, 2);
+ lean_ctor_release(x_1777, 3);
+ x_1815 = x_1777;
+} else {
+ lean_dec_ref(x_1777);
+ x_1815 = lean_box(0);
+}
+x_1816 = 1;
+lean_inc(x_1);
+if (lean_is_scalar(x_1815)) {
+ x_1817 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1817 = x_1815;
+}
+lean_ctor_set(x_1817, 0, x_1);
+lean_ctor_set(x_1817, 1, x_2);
+lean_ctor_set(x_1817, 2, x_3);
+lean_ctor_set(x_1817, 3, x_1776);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1818 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1818 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1817, sizeof(void*)*4, x_1816);
+x_1819 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1819, 0, x_1811);
+lean_ctor_set(x_1819, 1, x_1812);
+lean_ctor_set(x_1819, 2, x_1813);
+lean_ctor_set(x_1819, 3, x_1814);
+lean_ctor_set_uint8(x_1819, sizeof(void*)*4, x_1816);
+x_1820 = 0;
+if (lean_is_scalar(x_1818)) {
+ x_1821 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1821 = x_1818;
+}
+lean_ctor_set(x_1821, 0, x_1817);
+lean_ctor_set(x_1821, 1, x_1809);
+lean_ctor_set(x_1821, 2, x_1810);
+lean_ctor_set(x_1821, 3, x_1819);
+lean_ctor_set_uint8(x_1821, sizeof(void*)*4, x_1820);
+return x_1821;
+}
+}
+else
+{
+uint8_t x_1822; 
+x_1822 = !lean_is_exclusive(x_1777);
+if (x_1822 == 0)
+{
+lean_object* x_1823; lean_object* x_1824; lean_object* x_1825; lean_object* x_1826; uint8_t x_1827; 
+x_1823 = lean_ctor_get(x_1777, 3);
+lean_dec(x_1823);
+x_1824 = lean_ctor_get(x_1777, 2);
+lean_dec(x_1824);
+x_1825 = lean_ctor_get(x_1777, 1);
+lean_dec(x_1825);
+x_1826 = lean_ctor_get(x_1777, 0);
+lean_dec(x_1826);
+x_1827 = 1;
+lean_ctor_set(x_1777, 3, x_4);
+lean_ctor_set(x_1777, 2, x_3);
+lean_ctor_set(x_1777, 1, x_2);
+lean_ctor_set(x_1777, 0, x_1);
+lean_ctor_set_uint8(x_1777, sizeof(void*)*4, x_1827);
+return x_1777;
+}
+else
+{
+uint8_t x_1828; lean_object* x_1829; 
+lean_dec(x_1777);
+x_1828 = 1;
+x_1829 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1829, 0, x_1);
+lean_ctor_set(x_1829, 1, x_2);
+lean_ctor_set(x_1829, 2, x_3);
+lean_ctor_set(x_1829, 3, x_4);
+lean_ctor_set_uint8(x_1829, sizeof(void*)*4, x_1828);
+return x_1829;
+}
+}
+}
+}
+else
+{
+uint8_t x_1830; 
+x_1830 = lean_ctor_get_uint8(x_1776, sizeof(void*)*4);
+if (x_1830 == 0)
+{
+lean_object* x_1831; 
+x_1831 = lean_ctor_get(x_4, 3);
+lean_inc(x_1831);
+if (lean_obj_tag(x_1831) == 0)
+{
+uint8_t x_1832; 
+x_1832 = !lean_is_exclusive(x_4);
+if (x_1832 == 0)
+{
+lean_object* x_1833; lean_object* x_1834; uint8_t x_1835; 
+x_1833 = lean_ctor_get(x_4, 3);
+lean_dec(x_1833);
+x_1834 = lean_ctor_get(x_4, 0);
+lean_dec(x_1834);
+x_1835 = !lean_is_exclusive(x_1776);
+if (x_1835 == 0)
+{
+lean_object* x_1836; lean_object* x_1837; lean_object* x_1838; lean_object* x_1839; uint8_t x_1840; uint8_t x_1841; 
+x_1836 = lean_ctor_get(x_1776, 0);
+x_1837 = lean_ctor_get(x_1776, 1);
+x_1838 = lean_ctor_get(x_1776, 2);
+x_1839 = lean_ctor_get(x_1776, 3);
+x_1840 = 1;
+lean_inc(x_1);
+lean_ctor_set(x_1776, 3, x_1836);
+lean_ctor_set(x_1776, 2, x_3);
+lean_ctor_set(x_1776, 1, x_2);
+lean_ctor_set(x_1776, 0, x_1);
+x_1841 = !lean_is_exclusive(x_1);
+if (x_1841 == 0)
+{
+lean_object* x_1842; lean_object* x_1843; lean_object* x_1844; lean_object* x_1845; uint8_t x_1846; 
+x_1842 = lean_ctor_get(x_1, 3);
+lean_dec(x_1842);
+x_1843 = lean_ctor_get(x_1, 2);
+lean_dec(x_1843);
+x_1844 = lean_ctor_get(x_1, 1);
+lean_dec(x_1844);
+x_1845 = lean_ctor_get(x_1, 0);
+lean_dec(x_1845);
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1840);
+lean_ctor_set(x_4, 0, x_1839);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1840);
+x_1846 = 0;
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_1838);
+lean_ctor_set(x_1, 1, x_1837);
+lean_ctor_set(x_1, 0, x_1776);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1846);
+return x_1;
+}
+else
+{
+uint8_t x_1847; lean_object* x_1848; 
+lean_dec(x_1);
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1840);
+lean_ctor_set(x_4, 0, x_1839);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1840);
+x_1847 = 0;
+x_1848 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1848, 0, x_1776);
+lean_ctor_set(x_1848, 1, x_1837);
+lean_ctor_set(x_1848, 2, x_1838);
+lean_ctor_set(x_1848, 3, x_4);
+lean_ctor_set_uint8(x_1848, sizeof(void*)*4, x_1847);
+return x_1848;
+}
+}
+else
+{
+lean_object* x_1849; lean_object* x_1850; lean_object* x_1851; lean_object* x_1852; uint8_t x_1853; lean_object* x_1854; lean_object* x_1855; uint8_t x_1856; lean_object* x_1857; 
+x_1849 = lean_ctor_get(x_1776, 0);
+x_1850 = lean_ctor_get(x_1776, 1);
+x_1851 = lean_ctor_get(x_1776, 2);
+x_1852 = lean_ctor_get(x_1776, 3);
+lean_inc(x_1852);
+lean_inc(x_1851);
+lean_inc(x_1850);
+lean_inc(x_1849);
+lean_dec(x_1776);
+x_1853 = 1;
+lean_inc(x_1);
+x_1854 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1854, 0, x_1);
+lean_ctor_set(x_1854, 1, x_2);
+lean_ctor_set(x_1854, 2, x_3);
+lean_ctor_set(x_1854, 3, x_1849);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1855 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1855 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1854, sizeof(void*)*4, x_1853);
+lean_ctor_set(x_4, 0, x_1852);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1853);
+x_1856 = 0;
+if (lean_is_scalar(x_1855)) {
+ x_1857 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1857 = x_1855;
+}
+lean_ctor_set(x_1857, 0, x_1854);
+lean_ctor_set(x_1857, 1, x_1850);
+lean_ctor_set(x_1857, 2, x_1851);
+lean_ctor_set(x_1857, 3, x_4);
+lean_ctor_set_uint8(x_1857, sizeof(void*)*4, x_1856);
+return x_1857;
+}
+}
+else
+{
+lean_object* x_1858; lean_object* x_1859; lean_object* x_1860; lean_object* x_1861; lean_object* x_1862; lean_object* x_1863; lean_object* x_1864; uint8_t x_1865; lean_object* x_1866; lean_object* x_1867; lean_object* x_1868; uint8_t x_1869; lean_object* x_1870; 
+x_1858 = lean_ctor_get(x_4, 1);
+x_1859 = lean_ctor_get(x_4, 2);
+lean_inc(x_1859);
+lean_inc(x_1858);
+lean_dec(x_4);
+x_1860 = lean_ctor_get(x_1776, 0);
+lean_inc(x_1860);
+x_1861 = lean_ctor_get(x_1776, 1);
+lean_inc(x_1861);
+x_1862 = lean_ctor_get(x_1776, 2);
+lean_inc(x_1862);
+x_1863 = lean_ctor_get(x_1776, 3);
+lean_inc(x_1863);
+if (lean_is_exclusive(x_1776)) {
+ lean_ctor_release(x_1776, 0);
+ lean_ctor_release(x_1776, 1);
+ lean_ctor_release(x_1776, 2);
+ lean_ctor_release(x_1776, 3);
+ x_1864 = x_1776;
+} else {
+ lean_dec_ref(x_1776);
+ x_1864 = lean_box(0);
+}
+x_1865 = 1;
+lean_inc(x_1);
+if (lean_is_scalar(x_1864)) {
+ x_1866 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1866 = x_1864;
+}
+lean_ctor_set(x_1866, 0, x_1);
+lean_ctor_set(x_1866, 1, x_2);
+lean_ctor_set(x_1866, 2, x_3);
+lean_ctor_set(x_1866, 3, x_1860);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1867 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1867 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1866, sizeof(void*)*4, x_1865);
+x_1868 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1868, 0, x_1863);
+lean_ctor_set(x_1868, 1, x_1858);
+lean_ctor_set(x_1868, 2, x_1859);
+lean_ctor_set(x_1868, 3, x_1831);
+lean_ctor_set_uint8(x_1868, sizeof(void*)*4, x_1865);
+x_1869 = 0;
+if (lean_is_scalar(x_1867)) {
+ x_1870 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1870 = x_1867;
+}
+lean_ctor_set(x_1870, 0, x_1866);
+lean_ctor_set(x_1870, 1, x_1861);
+lean_ctor_set(x_1870, 2, x_1862);
+lean_ctor_set(x_1870, 3, x_1868);
+lean_ctor_set_uint8(x_1870, sizeof(void*)*4, x_1869);
+return x_1870;
+}
+}
+else
+{
+uint8_t x_1871; 
+x_1871 = lean_ctor_get_uint8(x_1831, sizeof(void*)*4);
 if (x_1871 == 0)
 {
-lean_object* x_1872; 
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-x_1872 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1872, 0, x_1);
-lean_ctor_set(x_1872, 1, x_2);
-lean_ctor_set(x_1872, 2, x_3);
-lean_ctor_set(x_1872, 3, x_4);
-lean_ctor_set_uint8(x_1872, sizeof(void*)*4, x_1833);
-return x_1872;
+uint8_t x_1872; 
+x_1872 = !lean_is_exclusive(x_4);
+if (x_1872 == 0)
+{
+lean_object* x_1873; lean_object* x_1874; lean_object* x_1875; lean_object* x_1876; uint8_t x_1877; 
+x_1873 = lean_ctor_get(x_4, 1);
+x_1874 = lean_ctor_get(x_4, 2);
+x_1875 = lean_ctor_get(x_4, 3);
+lean_dec(x_1875);
+x_1876 = lean_ctor_get(x_4, 0);
+lean_dec(x_1876);
+x_1877 = !lean_is_exclusive(x_1776);
+if (x_1877 == 0)
+{
+uint8_t x_1878; 
+x_1878 = !lean_is_exclusive(x_1831);
+if (x_1878 == 0)
+{
+lean_object* x_1879; lean_object* x_1880; lean_object* x_1881; lean_object* x_1882; lean_object* x_1883; lean_object* x_1884; lean_object* x_1885; lean_object* x_1886; uint8_t x_1887; uint8_t x_1888; 
+x_1879 = lean_ctor_get(x_1776, 0);
+x_1880 = lean_ctor_get(x_1776, 1);
+x_1881 = lean_ctor_get(x_1776, 2);
+x_1882 = lean_ctor_get(x_1776, 3);
+x_1883 = lean_ctor_get(x_1831, 0);
+x_1884 = lean_ctor_get(x_1831, 1);
+x_1885 = lean_ctor_get(x_1831, 2);
+x_1886 = lean_ctor_get(x_1831, 3);
+lean_ctor_set(x_1831, 3, x_1882);
+lean_ctor_set(x_1831, 2, x_1881);
+lean_ctor_set(x_1831, 1, x_1880);
+lean_ctor_set(x_1831, 0, x_1879);
+x_1887 = 1;
+lean_inc(x_1);
+lean_ctor_set(x_1776, 3, x_1831);
+lean_ctor_set(x_1776, 2, x_3);
+lean_ctor_set(x_1776, 1, x_2);
+lean_ctor_set(x_1776, 0, x_1);
+x_1888 = !lean_is_exclusive(x_1);
+if (x_1888 == 0)
+{
+lean_object* x_1889; lean_object* x_1890; lean_object* x_1891; lean_object* x_1892; uint8_t x_1893; 
+x_1889 = lean_ctor_get(x_1, 3);
+lean_dec(x_1889);
+x_1890 = lean_ctor_get(x_1, 2);
+lean_dec(x_1890);
+x_1891 = lean_ctor_get(x_1, 1);
+lean_dec(x_1891);
+x_1892 = lean_ctor_get(x_1, 0);
+lean_dec(x_1892);
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1887);
+lean_ctor_set(x_4, 3, x_1886);
+lean_ctor_set(x_4, 2, x_1885);
+lean_ctor_set(x_4, 1, x_1884);
+lean_ctor_set(x_4, 0, x_1883);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1887);
+x_1893 = 0;
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_1874);
+lean_ctor_set(x_1, 1, x_1873);
+lean_ctor_set(x_1, 0, x_1776);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1893);
+return x_1;
 }
 else
 {
-lean_object* x_1873; lean_object* x_1874; lean_object* x_1875; lean_object* x_1876; lean_object* x_1877; lean_object* x_1878; 
-x_1873 = lean_ctor_get(x_234, 0);
-x_1874 = lean_ctor_get(x_234, 1);
-x_1875 = lean_ctor_get(x_234, 2);
-x_1876 = lean_ctor_get(x_234, 3);
-lean_inc(x_1876);
-lean_inc(x_1875);
-lean_inc(x_1874);
-lean_inc(x_1873);
-lean_dec(x_234);
-x_1877 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1877, 0, x_1873);
-lean_ctor_set(x_1877, 1, x_1874);
-lean_ctor_set(x_1877, 2, x_1875);
-lean_ctor_set(x_1877, 3, x_1876);
-lean_ctor_set_uint8(x_1877, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 0, x_1877);
-x_1878 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1878, 0, x_1);
-lean_ctor_set(x_1878, 1, x_2);
-lean_ctor_set(x_1878, 2, x_3);
-lean_ctor_set(x_1878, 3, x_4);
-lean_ctor_set_uint8(x_1878, sizeof(void*)*4, x_1833);
-return x_1878;
-}
-}
-else
-{
-lean_object* x_1879; lean_object* x_1880; lean_object* x_1881; lean_object* x_1882; lean_object* x_1883; lean_object* x_1884; lean_object* x_1885; lean_object* x_1886; lean_object* x_1887; lean_object* x_1888; 
-x_1879 = lean_ctor_get(x_1, 1);
-x_1880 = lean_ctor_get(x_1, 2);
-lean_inc(x_1880);
-lean_inc(x_1879);
+uint8_t x_1894; lean_object* x_1895; 
 lean_dec(x_1);
-x_1881 = lean_ctor_get(x_234, 0);
-lean_inc(x_1881);
-x_1882 = lean_ctor_get(x_234, 1);
-lean_inc(x_1882);
-x_1883 = lean_ctor_get(x_234, 2);
-lean_inc(x_1883);
-x_1884 = lean_ctor_get(x_234, 3);
-lean_inc(x_1884);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1885 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_1885 = lean_box(0);
-}
-if (lean_is_scalar(x_1885)) {
- x_1886 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1886 = x_1885;
-}
-lean_ctor_set(x_1886, 0, x_1881);
-lean_ctor_set(x_1886, 1, x_1882);
-lean_ctor_set(x_1886, 2, x_1883);
-lean_ctor_set(x_1886, 3, x_1884);
-lean_ctor_set_uint8(x_1886, sizeof(void*)*4, x_1833);
-x_1887 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1887, 0, x_1886);
-lean_ctor_set(x_1887, 1, x_1879);
-lean_ctor_set(x_1887, 2, x_1880);
-lean_ctor_set(x_1887, 3, x_1265);
-lean_ctor_set_uint8(x_1887, sizeof(void*)*4, x_233);
-x_1888 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1888, 0, x_1887);
-lean_ctor_set(x_1888, 1, x_2);
-lean_ctor_set(x_1888, 2, x_3);
-lean_ctor_set(x_1888, 3, x_4);
-lean_ctor_set_uint8(x_1888, sizeof(void*)*4, x_1833);
-return x_1888;
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1887);
+lean_ctor_set(x_4, 3, x_1886);
+lean_ctor_set(x_4, 2, x_1885);
+lean_ctor_set(x_4, 1, x_1884);
+lean_ctor_set(x_4, 0, x_1883);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1887);
+x_1894 = 0;
+x_1895 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1895, 0, x_1776);
+lean_ctor_set(x_1895, 1, x_1873);
+lean_ctor_set(x_1895, 2, x_1874);
+lean_ctor_set(x_1895, 3, x_4);
+lean_ctor_set_uint8(x_1895, sizeof(void*)*4, x_1894);
+return x_1895;
 }
 }
 else
 {
-uint8_t x_1889; 
-x_1889 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
-if (x_1889 == 0)
-{
-lean_object* x_1890; 
-x_1890 = lean_ctor_get(x_4, 0);
-lean_inc(x_1890);
-if (lean_obj_tag(x_1890) == 0)
-{
-lean_object* x_1891; 
-x_1891 = lean_ctor_get(x_4, 3);
-lean_inc(x_1891);
-if (lean_obj_tag(x_1891) == 0)
-{
-uint8_t x_1892; 
-x_1892 = !lean_is_exclusive(x_1);
-if (x_1892 == 0)
-{
-lean_object* x_1893; lean_object* x_1894; lean_object* x_1895; lean_object* x_1896; uint8_t x_1897; 
-x_1893 = lean_ctor_get(x_1, 1);
-x_1894 = lean_ctor_get(x_1, 2);
-x_1895 = lean_ctor_get(x_1, 3);
-lean_dec(x_1895);
-x_1896 = lean_ctor_get(x_1, 0);
-lean_dec(x_1896);
-x_1897 = !lean_is_exclusive(x_234);
-if (x_1897 == 0)
-{
-uint8_t x_1898; 
-x_1898 = !lean_is_exclusive(x_4);
-if (x_1898 == 0)
-{
-lean_object* x_1899; lean_object* x_1900; lean_object* x_1901; lean_object* x_1902; lean_object* x_1903; lean_object* x_1904; lean_object* x_1905; lean_object* x_1906; lean_object* x_1907; 
-x_1899 = lean_ctor_get(x_234, 0);
-x_1900 = lean_ctor_get(x_234, 1);
-x_1901 = lean_ctor_get(x_234, 2);
-x_1902 = lean_ctor_get(x_234, 3);
-x_1903 = lean_ctor_get(x_4, 1);
-x_1904 = lean_ctor_get(x_4, 2);
-x_1905 = lean_ctor_get(x_4, 3);
-lean_dec(x_1905);
-x_1906 = lean_ctor_get(x_4, 0);
-lean_dec(x_1906);
-lean_ctor_set(x_4, 3, x_1902);
-lean_ctor_set(x_4, 2, x_1901);
-lean_ctor_set(x_4, 1, x_1900);
-lean_ctor_set(x_4, 0, x_1899);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_1265);
-lean_ctor_set(x_234, 2, x_1894);
-lean_ctor_set(x_234, 1, x_1893);
-lean_ctor_set(x_234, 0, x_4);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_1891);
-lean_ctor_set(x_1, 2, x_1904);
-lean_ctor_set(x_1, 1, x_1903);
-lean_ctor_set(x_1, 0, x_1891);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_1907 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1907, 0, x_234);
-lean_ctor_set(x_1907, 1, x_2);
-lean_ctor_set(x_1907, 2, x_3);
-lean_ctor_set(x_1907, 3, x_1);
-lean_ctor_set_uint8(x_1907, sizeof(void*)*4, x_1833);
-return x_1907;
+lean_object* x_1896; lean_object* x_1897; lean_object* x_1898; lean_object* x_1899; lean_object* x_1900; lean_object* x_1901; lean_object* x_1902; lean_object* x_1903; lean_object* x_1904; uint8_t x_1905; lean_object* x_1906; uint8_t x_1907; lean_object* x_1908; 
+x_1896 = lean_ctor_get(x_1776, 0);
+x_1897 = lean_ctor_get(x_1776, 1);
+x_1898 = lean_ctor_get(x_1776, 2);
+x_1899 = lean_ctor_get(x_1776, 3);
+x_1900 = lean_ctor_get(x_1831, 0);
+x_1901 = lean_ctor_get(x_1831, 1);
+x_1902 = lean_ctor_get(x_1831, 2);
+x_1903 = lean_ctor_get(x_1831, 3);
+lean_inc(x_1903);
+lean_inc(x_1902);
+lean_inc(x_1901);
+lean_inc(x_1900);
+lean_dec(x_1831);
+x_1904 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1904, 0, x_1896);
+lean_ctor_set(x_1904, 1, x_1897);
+lean_ctor_set(x_1904, 2, x_1898);
+lean_ctor_set(x_1904, 3, x_1899);
+lean_ctor_set_uint8(x_1904, sizeof(void*)*4, x_1871);
+x_1905 = 1;
+lean_inc(x_1);
+lean_ctor_set(x_1776, 3, x_1904);
+lean_ctor_set(x_1776, 2, x_3);
+lean_ctor_set(x_1776, 1, x_2);
+lean_ctor_set(x_1776, 0, x_1);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1906 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1906 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1905);
+lean_ctor_set(x_4, 3, x_1903);
+lean_ctor_set(x_4, 2, x_1902);
+lean_ctor_set(x_4, 1, x_1901);
+lean_ctor_set(x_4, 0, x_1900);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1905);
+x_1907 = 0;
+if (lean_is_scalar(x_1906)) {
+ x_1908 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1908 = x_1906;
+}
+lean_ctor_set(x_1908, 0, x_1776);
+lean_ctor_set(x_1908, 1, x_1873);
+lean_ctor_set(x_1908, 2, x_1874);
+lean_ctor_set(x_1908, 3, x_4);
+lean_ctor_set_uint8(x_1908, sizeof(void*)*4, x_1907);
+return x_1908;
+}
 }
 else
 {
-lean_object* x_1908; lean_object* x_1909; lean_object* x_1910; lean_object* x_1911; lean_object* x_1912; lean_object* x_1913; lean_object* x_1914; lean_object* x_1915; 
-x_1908 = lean_ctor_get(x_234, 0);
-x_1909 = lean_ctor_get(x_234, 1);
-x_1910 = lean_ctor_get(x_234, 2);
-x_1911 = lean_ctor_get(x_234, 3);
-x_1912 = lean_ctor_get(x_4, 1);
-x_1913 = lean_ctor_get(x_4, 2);
-lean_inc(x_1913);
+lean_object* x_1909; lean_object* x_1910; lean_object* x_1911; lean_object* x_1912; lean_object* x_1913; lean_object* x_1914; lean_object* x_1915; lean_object* x_1916; lean_object* x_1917; lean_object* x_1918; uint8_t x_1919; lean_object* x_1920; lean_object* x_1921; uint8_t x_1922; lean_object* x_1923; 
+x_1909 = lean_ctor_get(x_1776, 0);
+x_1910 = lean_ctor_get(x_1776, 1);
+x_1911 = lean_ctor_get(x_1776, 2);
+x_1912 = lean_ctor_get(x_1776, 3);
 lean_inc(x_1912);
-lean_dec(x_4);
-x_1914 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1914, 0, x_1908);
-lean_ctor_set(x_1914, 1, x_1909);
-lean_ctor_set(x_1914, 2, x_1910);
-lean_ctor_set(x_1914, 3, x_1911);
-lean_ctor_set_uint8(x_1914, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_1265);
-lean_ctor_set(x_234, 2, x_1894);
-lean_ctor_set(x_234, 1, x_1893);
-lean_ctor_set(x_234, 0, x_1914);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_1891);
-lean_ctor_set(x_1, 2, x_1913);
-lean_ctor_set(x_1, 1, x_1912);
-lean_ctor_set(x_1, 0, x_1891);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_1915 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1915, 0, x_234);
-lean_ctor_set(x_1915, 1, x_2);
-lean_ctor_set(x_1915, 2, x_3);
-lean_ctor_set(x_1915, 3, x_1);
-lean_ctor_set_uint8(x_1915, sizeof(void*)*4, x_1833);
-return x_1915;
-}
-}
-else
-{
-lean_object* x_1916; lean_object* x_1917; lean_object* x_1918; lean_object* x_1919; lean_object* x_1920; lean_object* x_1921; lean_object* x_1922; lean_object* x_1923; lean_object* x_1924; lean_object* x_1925; 
-x_1916 = lean_ctor_get(x_234, 0);
-x_1917 = lean_ctor_get(x_234, 1);
-x_1918 = lean_ctor_get(x_234, 2);
-x_1919 = lean_ctor_get(x_234, 3);
-lean_inc(x_1919);
-lean_inc(x_1918);
-lean_inc(x_1917);
+lean_inc(x_1911);
+lean_inc(x_1910);
+lean_inc(x_1909);
+lean_dec(x_1776);
+x_1913 = lean_ctor_get(x_1831, 0);
+lean_inc(x_1913);
+x_1914 = lean_ctor_get(x_1831, 1);
+lean_inc(x_1914);
+x_1915 = lean_ctor_get(x_1831, 2);
+lean_inc(x_1915);
+x_1916 = lean_ctor_get(x_1831, 3);
 lean_inc(x_1916);
-lean_dec(x_234);
-x_1920 = lean_ctor_get(x_4, 1);
-lean_inc(x_1920);
-x_1921 = lean_ctor_get(x_4, 2);
-lean_inc(x_1921);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1922 = x_4;
+if (lean_is_exclusive(x_1831)) {
+ lean_ctor_release(x_1831, 0);
+ lean_ctor_release(x_1831, 1);
+ lean_ctor_release(x_1831, 2);
+ lean_ctor_release(x_1831, 3);
+ x_1917 = x_1831;
 } else {
- lean_dec_ref(x_4);
- x_1922 = lean_box(0);
+ lean_dec_ref(x_1831);
+ x_1917 = lean_box(0);
 }
-if (lean_is_scalar(x_1922)) {
+if (lean_is_scalar(x_1917)) {
+ x_1918 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1918 = x_1917;
+}
+lean_ctor_set(x_1918, 0, x_1909);
+lean_ctor_set(x_1918, 1, x_1910);
+lean_ctor_set(x_1918, 2, x_1911);
+lean_ctor_set(x_1918, 3, x_1912);
+lean_ctor_set_uint8(x_1918, sizeof(void*)*4, x_1871);
+x_1919 = 1;
+lean_inc(x_1);
+x_1920 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1920, 0, x_1);
+lean_ctor_set(x_1920, 1, x_2);
+lean_ctor_set(x_1920, 2, x_3);
+lean_ctor_set(x_1920, 3, x_1918);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1921 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1921 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1920, sizeof(void*)*4, x_1919);
+lean_ctor_set(x_4, 3, x_1916);
+lean_ctor_set(x_4, 2, x_1915);
+lean_ctor_set(x_4, 1, x_1914);
+lean_ctor_set(x_4, 0, x_1913);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1919);
+x_1922 = 0;
+if (lean_is_scalar(x_1921)) {
  x_1923 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1923 = x_1922;
+ x_1923 = x_1921;
 }
-lean_ctor_set(x_1923, 0, x_1916);
-lean_ctor_set(x_1923, 1, x_1917);
-lean_ctor_set(x_1923, 2, x_1918);
-lean_ctor_set(x_1923, 3, x_1919);
-lean_ctor_set_uint8(x_1923, sizeof(void*)*4, x_1833);
-x_1924 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1924, 0, x_1923);
-lean_ctor_set(x_1924, 1, x_1893);
-lean_ctor_set(x_1924, 2, x_1894);
-lean_ctor_set(x_1924, 3, x_1265);
-lean_ctor_set_uint8(x_1924, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_1891);
-lean_ctor_set(x_1, 2, x_1921);
-lean_ctor_set(x_1, 1, x_1920);
-lean_ctor_set(x_1, 0, x_1891);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_1925 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1925, 0, x_1924);
-lean_ctor_set(x_1925, 1, x_2);
-lean_ctor_set(x_1925, 2, x_3);
-lean_ctor_set(x_1925, 3, x_1);
-lean_ctor_set_uint8(x_1925, sizeof(void*)*4, x_1833);
-return x_1925;
+lean_ctor_set(x_1923, 0, x_1920);
+lean_ctor_set(x_1923, 1, x_1873);
+lean_ctor_set(x_1923, 2, x_1874);
+lean_ctor_set(x_1923, 3, x_4);
+lean_ctor_set_uint8(x_1923, sizeof(void*)*4, x_1922);
+return x_1923;
 }
 }
 else
 {
-lean_object* x_1926; lean_object* x_1927; lean_object* x_1928; lean_object* x_1929; lean_object* x_1930; lean_object* x_1931; lean_object* x_1932; lean_object* x_1933; lean_object* x_1934; lean_object* x_1935; lean_object* x_1936; lean_object* x_1937; lean_object* x_1938; lean_object* x_1939; 
-x_1926 = lean_ctor_get(x_1, 1);
-x_1927 = lean_ctor_get(x_1, 2);
-lean_inc(x_1927);
+lean_object* x_1924; lean_object* x_1925; lean_object* x_1926; lean_object* x_1927; lean_object* x_1928; lean_object* x_1929; lean_object* x_1930; lean_object* x_1931; lean_object* x_1932; lean_object* x_1933; lean_object* x_1934; lean_object* x_1935; lean_object* x_1936; uint8_t x_1937; lean_object* x_1938; lean_object* x_1939; lean_object* x_1940; uint8_t x_1941; lean_object* x_1942; 
+x_1924 = lean_ctor_get(x_4, 1);
+x_1925 = lean_ctor_get(x_4, 2);
+lean_inc(x_1925);
+lean_inc(x_1924);
+lean_dec(x_4);
+x_1926 = lean_ctor_get(x_1776, 0);
 lean_inc(x_1926);
-lean_dec(x_1);
-x_1928 = lean_ctor_get(x_234, 0);
+x_1927 = lean_ctor_get(x_1776, 1);
+lean_inc(x_1927);
+x_1928 = lean_ctor_get(x_1776, 2);
 lean_inc(x_1928);
-x_1929 = lean_ctor_get(x_234, 1);
+x_1929 = lean_ctor_get(x_1776, 3);
 lean_inc(x_1929);
-x_1930 = lean_ctor_get(x_234, 2);
-lean_inc(x_1930);
-x_1931 = lean_ctor_get(x_234, 3);
-lean_inc(x_1931);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_1932 = x_234;
+if (lean_is_exclusive(x_1776)) {
+ lean_ctor_release(x_1776, 0);
+ lean_ctor_release(x_1776, 1);
+ lean_ctor_release(x_1776, 2);
+ lean_ctor_release(x_1776, 3);
+ x_1930 = x_1776;
 } else {
- lean_dec_ref(x_234);
- x_1932 = lean_box(0);
+ lean_dec_ref(x_1776);
+ x_1930 = lean_box(0);
 }
-x_1933 = lean_ctor_get(x_4, 1);
+x_1931 = lean_ctor_get(x_1831, 0);
+lean_inc(x_1931);
+x_1932 = lean_ctor_get(x_1831, 1);
+lean_inc(x_1932);
+x_1933 = lean_ctor_get(x_1831, 2);
 lean_inc(x_1933);
-x_1934 = lean_ctor_get(x_4, 2);
+x_1934 = lean_ctor_get(x_1831, 3);
 lean_inc(x_1934);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1935 = x_4;
+if (lean_is_exclusive(x_1831)) {
+ lean_ctor_release(x_1831, 0);
+ lean_ctor_release(x_1831, 1);
+ lean_ctor_release(x_1831, 2);
+ lean_ctor_release(x_1831, 3);
+ x_1935 = x_1831;
 } else {
- lean_dec_ref(x_4);
+ lean_dec_ref(x_1831);
  x_1935 = lean_box(0);
 }
 if (lean_is_scalar(x_1935)) {
@@ -14435,5796 +15492,515 @@ if (lean_is_scalar(x_1935)) {
 } else {
  x_1936 = x_1935;
 }
-lean_ctor_set(x_1936, 0, x_1928);
-lean_ctor_set(x_1936, 1, x_1929);
-lean_ctor_set(x_1936, 2, x_1930);
-lean_ctor_set(x_1936, 3, x_1931);
-lean_ctor_set_uint8(x_1936, sizeof(void*)*4, x_1833);
-if (lean_is_scalar(x_1932)) {
- x_1937 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1936, 0, x_1926);
+lean_ctor_set(x_1936, 1, x_1927);
+lean_ctor_set(x_1936, 2, x_1928);
+lean_ctor_set(x_1936, 3, x_1929);
+lean_ctor_set_uint8(x_1936, sizeof(void*)*4, x_1871);
+x_1937 = 1;
+lean_inc(x_1);
+if (lean_is_scalar(x_1930)) {
+ x_1938 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_1937 = x_1932;
+ x_1938 = x_1930;
 }
-lean_ctor_set(x_1937, 0, x_1936);
-lean_ctor_set(x_1937, 1, x_1926);
-lean_ctor_set(x_1937, 2, x_1927);
-lean_ctor_set(x_1937, 3, x_1265);
-lean_ctor_set_uint8(x_1937, sizeof(void*)*4, x_1889);
-x_1938 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1938, 0, x_1891);
-lean_ctor_set(x_1938, 1, x_1933);
-lean_ctor_set(x_1938, 2, x_1934);
-lean_ctor_set(x_1938, 3, x_1891);
-lean_ctor_set_uint8(x_1938, sizeof(void*)*4, x_1889);
-x_1939 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1939, 0, x_1937);
-lean_ctor_set(x_1939, 1, x_2);
-lean_ctor_set(x_1939, 2, x_3);
-lean_ctor_set(x_1939, 3, x_1938);
-lean_ctor_set_uint8(x_1939, sizeof(void*)*4, x_1833);
-return x_1939;
+lean_ctor_set(x_1938, 0, x_1);
+lean_ctor_set(x_1938, 1, x_2);
+lean_ctor_set(x_1938, 2, x_3);
+lean_ctor_set(x_1938, 3, x_1936);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1939 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1939 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1938, sizeof(void*)*4, x_1937);
+x_1940 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1940, 0, x_1931);
+lean_ctor_set(x_1940, 1, x_1932);
+lean_ctor_set(x_1940, 2, x_1933);
+lean_ctor_set(x_1940, 3, x_1934);
+lean_ctor_set_uint8(x_1940, sizeof(void*)*4, x_1937);
+x_1941 = 0;
+if (lean_is_scalar(x_1939)) {
+ x_1942 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1942 = x_1939;
+}
+lean_ctor_set(x_1942, 0, x_1938);
+lean_ctor_set(x_1942, 1, x_1924);
+lean_ctor_set(x_1942, 2, x_1925);
+lean_ctor_set(x_1942, 3, x_1940);
+lean_ctor_set_uint8(x_1942, sizeof(void*)*4, x_1941);
+return x_1942;
 }
 }
 else
 {
-uint8_t x_1940; 
-x_1940 = lean_ctor_get_uint8(x_1891, sizeof(void*)*4);
-if (x_1940 == 0)
+uint8_t x_1943; 
+x_1943 = !lean_is_exclusive(x_4);
+if (x_1943 == 0)
 {
-uint8_t x_1941; 
-x_1941 = !lean_is_exclusive(x_1);
-if (x_1941 == 0)
-{
-lean_object* x_1942; lean_object* x_1943; lean_object* x_1944; lean_object* x_1945; uint8_t x_1946; 
-x_1942 = lean_ctor_get(x_1, 1);
-x_1943 = lean_ctor_get(x_1, 2);
-x_1944 = lean_ctor_get(x_1, 3);
+lean_object* x_1944; lean_object* x_1945; uint8_t x_1946; 
+x_1944 = lean_ctor_get(x_4, 3);
 lean_dec(x_1944);
-x_1945 = lean_ctor_get(x_1, 0);
+x_1945 = lean_ctor_get(x_4, 0);
 lean_dec(x_1945);
-x_1946 = !lean_is_exclusive(x_234);
+x_1946 = !lean_is_exclusive(x_1776);
 if (x_1946 == 0)
 {
-uint8_t x_1947; 
-x_1947 = !lean_is_exclusive(x_4);
-if (x_1947 == 0)
+lean_object* x_1947; lean_object* x_1948; lean_object* x_1949; lean_object* x_1950; uint8_t x_1951; uint8_t x_1952; 
+x_1947 = lean_ctor_get(x_1776, 0);
+x_1948 = lean_ctor_get(x_1776, 1);
+x_1949 = lean_ctor_get(x_1776, 2);
+x_1950 = lean_ctor_get(x_1776, 3);
+x_1951 = 1;
+lean_inc(x_1);
+lean_ctor_set(x_1776, 3, x_1947);
+lean_ctor_set(x_1776, 2, x_3);
+lean_ctor_set(x_1776, 1, x_2);
+lean_ctor_set(x_1776, 0, x_1);
+x_1952 = !lean_is_exclusive(x_1);
+if (x_1952 == 0)
 {
-lean_object* x_1948; lean_object* x_1949; lean_object* x_1950; lean_object* x_1951; lean_object* x_1952; lean_object* x_1953; lean_object* x_1954; lean_object* x_1955; uint8_t x_1956; 
-x_1948 = lean_ctor_get(x_234, 0);
-x_1949 = lean_ctor_get(x_234, 1);
-x_1950 = lean_ctor_get(x_234, 2);
-x_1951 = lean_ctor_get(x_234, 3);
-x_1952 = lean_ctor_get(x_4, 1);
-x_1953 = lean_ctor_get(x_4, 2);
-x_1954 = lean_ctor_get(x_4, 3);
+lean_object* x_1953; lean_object* x_1954; lean_object* x_1955; lean_object* x_1956; uint8_t x_1957; 
+x_1953 = lean_ctor_get(x_1, 3);
+lean_dec(x_1953);
+x_1954 = lean_ctor_get(x_1, 2);
 lean_dec(x_1954);
-x_1955 = lean_ctor_get(x_4, 0);
+x_1955 = lean_ctor_get(x_1, 1);
 lean_dec(x_1955);
-x_1956 = !lean_is_exclusive(x_1891);
-if (x_1956 == 0)
-{
-lean_object* x_1957; lean_object* x_1958; lean_object* x_1959; lean_object* x_1960; uint8_t x_1961; 
-x_1957 = lean_ctor_get(x_1891, 0);
-x_1958 = lean_ctor_get(x_1891, 1);
-x_1959 = lean_ctor_get(x_1891, 2);
-x_1960 = lean_ctor_get(x_1891, 3);
-lean_ctor_set(x_1891, 3, x_1951);
-lean_ctor_set(x_1891, 2, x_1950);
-lean_ctor_set(x_1891, 1, x_1949);
-lean_ctor_set(x_1891, 0, x_1948);
-lean_ctor_set_uint8(x_1891, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1943);
-lean_ctor_set(x_4, 1, x_1942);
-lean_ctor_set(x_4, 0, x_1891);
-x_1961 = !lean_is_exclusive(x_1265);
-if (x_1961 == 0)
-{
-lean_object* x_1962; lean_object* x_1963; lean_object* x_1964; lean_object* x_1965; 
-x_1962 = lean_ctor_get(x_1265, 3);
-lean_dec(x_1962);
-x_1963 = lean_ctor_get(x_1265, 2);
-lean_dec(x_1963);
-x_1964 = lean_ctor_get(x_1265, 1);
-lean_dec(x_1964);
-x_1965 = lean_ctor_get(x_1265, 0);
-lean_dec(x_1965);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1940);
-lean_ctor_set(x_1265, 3, x_1890);
-lean_ctor_set(x_1265, 2, x_3);
-lean_ctor_set(x_1265, 1, x_2);
-lean_ctor_set(x_1265, 0, x_4);
-lean_ctor_set(x_234, 3, x_1960);
-lean_ctor_set(x_234, 2, x_1959);
-lean_ctor_set(x_234, 1, x_1958);
-lean_ctor_set(x_234, 0, x_1957);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1953);
-lean_ctor_set(x_1, 1, x_1952);
-lean_ctor_set(x_1, 0, x_1265);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
+x_1956 = lean_ctor_get(x_1, 0);
+lean_dec(x_1956);
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1951);
+lean_ctor_set(x_4, 0, x_1950);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1951);
+x_1957 = 0;
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_1949);
+lean_ctor_set(x_1, 1, x_1948);
+lean_ctor_set(x_1, 0, x_1776);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1957);
 return x_1;
 }
 else
 {
-lean_object* x_1966; 
-lean_dec(x_1265);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1940);
-x_1966 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1966, 0, x_4);
-lean_ctor_set(x_1966, 1, x_2);
-lean_ctor_set(x_1966, 2, x_3);
-lean_ctor_set(x_1966, 3, x_1890);
-lean_ctor_set_uint8(x_1966, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_1960);
-lean_ctor_set(x_234, 2, x_1959);
-lean_ctor_set(x_234, 1, x_1958);
-lean_ctor_set(x_234, 0, x_1957);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1953);
-lean_ctor_set(x_1, 1, x_1952);
-lean_ctor_set(x_1, 0, x_1966);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
-return x_1;
+uint8_t x_1958; lean_object* x_1959; 
+lean_dec(x_1);
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1951);
+lean_ctor_set(x_4, 0, x_1950);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1951);
+x_1958 = 0;
+x_1959 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1959, 0, x_1776);
+lean_ctor_set(x_1959, 1, x_1948);
+lean_ctor_set(x_1959, 2, x_1949);
+lean_ctor_set(x_1959, 3, x_4);
+lean_ctor_set_uint8(x_1959, sizeof(void*)*4, x_1958);
+return x_1959;
 }
 }
 else
 {
-lean_object* x_1967; lean_object* x_1968; lean_object* x_1969; lean_object* x_1970; lean_object* x_1971; lean_object* x_1972; lean_object* x_1973; 
-x_1967 = lean_ctor_get(x_1891, 0);
-x_1968 = lean_ctor_get(x_1891, 1);
-x_1969 = lean_ctor_get(x_1891, 2);
-x_1970 = lean_ctor_get(x_1891, 3);
+lean_object* x_1960; lean_object* x_1961; lean_object* x_1962; lean_object* x_1963; uint8_t x_1964; lean_object* x_1965; lean_object* x_1966; uint8_t x_1967; lean_object* x_1968; 
+x_1960 = lean_ctor_get(x_1776, 0);
+x_1961 = lean_ctor_get(x_1776, 1);
+x_1962 = lean_ctor_get(x_1776, 2);
+x_1963 = lean_ctor_get(x_1776, 3);
+lean_inc(x_1963);
+lean_inc(x_1962);
+lean_inc(x_1961);
+lean_inc(x_1960);
+lean_dec(x_1776);
+x_1964 = 1;
+lean_inc(x_1);
+x_1965 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1965, 0, x_1);
+lean_ctor_set(x_1965, 1, x_2);
+lean_ctor_set(x_1965, 2, x_3);
+lean_ctor_set(x_1965, 3, x_1960);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1966 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1966 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1965, sizeof(void*)*4, x_1964);
+lean_ctor_set(x_4, 0, x_1963);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1964);
+x_1967 = 0;
+if (lean_is_scalar(x_1966)) {
+ x_1968 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1968 = x_1966;
+}
+lean_ctor_set(x_1968, 0, x_1965);
+lean_ctor_set(x_1968, 1, x_1961);
+lean_ctor_set(x_1968, 2, x_1962);
+lean_ctor_set(x_1968, 3, x_4);
+lean_ctor_set_uint8(x_1968, sizeof(void*)*4, x_1967);
+return x_1968;
+}
+}
+else
+{
+lean_object* x_1969; lean_object* x_1970; lean_object* x_1971; lean_object* x_1972; lean_object* x_1973; lean_object* x_1974; lean_object* x_1975; uint8_t x_1976; lean_object* x_1977; lean_object* x_1978; lean_object* x_1979; uint8_t x_1980; lean_object* x_1981; 
+x_1969 = lean_ctor_get(x_4, 1);
+x_1970 = lean_ctor_get(x_4, 2);
 lean_inc(x_1970);
 lean_inc(x_1969);
-lean_inc(x_1968);
-lean_inc(x_1967);
-lean_dec(x_1891);
-x_1971 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1971, 0, x_1948);
-lean_ctor_set(x_1971, 1, x_1949);
-lean_ctor_set(x_1971, 2, x_1950);
-lean_ctor_set(x_1971, 3, x_1951);
-lean_ctor_set_uint8(x_1971, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_1943);
-lean_ctor_set(x_4, 1, x_1942);
-lean_ctor_set(x_4, 0, x_1971);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_1972 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_1972 = lean_box(0);
-}
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_1940);
-if (lean_is_scalar(x_1972)) {
- x_1973 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1973 = x_1972;
-}
-lean_ctor_set(x_1973, 0, x_4);
-lean_ctor_set(x_1973, 1, x_2);
-lean_ctor_set(x_1973, 2, x_3);
-lean_ctor_set(x_1973, 3, x_1890);
-lean_ctor_set_uint8(x_1973, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_1970);
-lean_ctor_set(x_234, 2, x_1969);
-lean_ctor_set(x_234, 1, x_1968);
-lean_ctor_set(x_234, 0, x_1967);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1953);
-lean_ctor_set(x_1, 1, x_1952);
-lean_ctor_set(x_1, 0, x_1973);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
-return x_1;
-}
-}
-else
-{
-lean_object* x_1974; lean_object* x_1975; lean_object* x_1976; lean_object* x_1977; lean_object* x_1978; lean_object* x_1979; lean_object* x_1980; lean_object* x_1981; lean_object* x_1982; lean_object* x_1983; lean_object* x_1984; lean_object* x_1985; lean_object* x_1986; lean_object* x_1987; lean_object* x_1988; 
-x_1974 = lean_ctor_get(x_234, 0);
-x_1975 = lean_ctor_get(x_234, 1);
-x_1976 = lean_ctor_get(x_234, 2);
-x_1977 = lean_ctor_get(x_234, 3);
-x_1978 = lean_ctor_get(x_4, 1);
-x_1979 = lean_ctor_get(x_4, 2);
-lean_inc(x_1979);
-lean_inc(x_1978);
 lean_dec(x_4);
-x_1980 = lean_ctor_get(x_1891, 0);
-lean_inc(x_1980);
-x_1981 = lean_ctor_get(x_1891, 1);
-lean_inc(x_1981);
-x_1982 = lean_ctor_get(x_1891, 2);
+x_1971 = lean_ctor_get(x_1776, 0);
+lean_inc(x_1971);
+x_1972 = lean_ctor_get(x_1776, 1);
+lean_inc(x_1972);
+x_1973 = lean_ctor_get(x_1776, 2);
+lean_inc(x_1973);
+x_1974 = lean_ctor_get(x_1776, 3);
+lean_inc(x_1974);
+if (lean_is_exclusive(x_1776)) {
+ lean_ctor_release(x_1776, 0);
+ lean_ctor_release(x_1776, 1);
+ lean_ctor_release(x_1776, 2);
+ lean_ctor_release(x_1776, 3);
+ x_1975 = x_1776;
+} else {
+ lean_dec_ref(x_1776);
+ x_1975 = lean_box(0);
+}
+x_1976 = 1;
+lean_inc(x_1);
+if (lean_is_scalar(x_1975)) {
+ x_1977 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1977 = x_1975;
+}
+lean_ctor_set(x_1977, 0, x_1);
+lean_ctor_set(x_1977, 1, x_2);
+lean_ctor_set(x_1977, 2, x_3);
+lean_ctor_set(x_1977, 3, x_1971);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_1978 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_1978 = lean_box(0);
+}
+lean_ctor_set_uint8(x_1977, sizeof(void*)*4, x_1976);
+x_1979 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1979, 0, x_1974);
+lean_ctor_set(x_1979, 1, x_1969);
+lean_ctor_set(x_1979, 2, x_1970);
+lean_ctor_set(x_1979, 3, x_1831);
+lean_ctor_set_uint8(x_1979, sizeof(void*)*4, x_1976);
+x_1980 = 0;
+if (lean_is_scalar(x_1978)) {
+ x_1981 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_1981 = x_1978;
+}
+lean_ctor_set(x_1981, 0, x_1977);
+lean_ctor_set(x_1981, 1, x_1972);
+lean_ctor_set(x_1981, 2, x_1973);
+lean_ctor_set(x_1981, 3, x_1979);
+lean_ctor_set_uint8(x_1981, sizeof(void*)*4, x_1980);
+return x_1981;
+}
+}
+}
+}
+else
+{
+lean_object* x_1982; 
+x_1982 = lean_ctor_get(x_4, 3);
 lean_inc(x_1982);
-x_1983 = lean_ctor_get(x_1891, 3);
-lean_inc(x_1983);
-if (lean_is_exclusive(x_1891)) {
- lean_ctor_release(x_1891, 0);
- lean_ctor_release(x_1891, 1);
- lean_ctor_release(x_1891, 2);
- lean_ctor_release(x_1891, 3);
- x_1984 = x_1891;
-} else {
- lean_dec_ref(x_1891);
- x_1984 = lean_box(0);
+if (lean_obj_tag(x_1982) == 0)
+{
+uint8_t x_1983; 
+x_1983 = !lean_is_exclusive(x_1776);
+if (x_1983 == 0)
+{
+lean_object* x_1984; lean_object* x_1985; lean_object* x_1986; lean_object* x_1987; uint8_t x_1988; 
+x_1984 = lean_ctor_get(x_1776, 3);
+lean_dec(x_1984);
+x_1985 = lean_ctor_get(x_1776, 2);
+lean_dec(x_1985);
+x_1986 = lean_ctor_get(x_1776, 1);
+lean_dec(x_1986);
+x_1987 = lean_ctor_get(x_1776, 0);
+lean_dec(x_1987);
+x_1988 = 1;
+lean_ctor_set(x_1776, 3, x_4);
+lean_ctor_set(x_1776, 2, x_3);
+lean_ctor_set(x_1776, 1, x_2);
+lean_ctor_set(x_1776, 0, x_1);
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_1988);
+return x_1776;
 }
-if (lean_is_scalar(x_1984)) {
- x_1985 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1985 = x_1984;
-}
-lean_ctor_set(x_1985, 0, x_1974);
-lean_ctor_set(x_1985, 1, x_1975);
-lean_ctor_set(x_1985, 2, x_1976);
-lean_ctor_set(x_1985, 3, x_1977);
-lean_ctor_set_uint8(x_1985, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-x_1986 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_1986, 0, x_1985);
-lean_ctor_set(x_1986, 1, x_1942);
-lean_ctor_set(x_1986, 2, x_1943);
-lean_ctor_set(x_1986, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_1987 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_1987 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1986, sizeof(void*)*4, x_1940);
-if (lean_is_scalar(x_1987)) {
- x_1988 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_1988 = x_1987;
-}
-lean_ctor_set(x_1988, 0, x_1986);
-lean_ctor_set(x_1988, 1, x_2);
-lean_ctor_set(x_1988, 2, x_3);
-lean_ctor_set(x_1988, 3, x_1890);
-lean_ctor_set_uint8(x_1988, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_1983);
-lean_ctor_set(x_234, 2, x_1982);
-lean_ctor_set(x_234, 1, x_1981);
-lean_ctor_set(x_234, 0, x_1980);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_1979);
-lean_ctor_set(x_1, 1, x_1978);
-lean_ctor_set(x_1, 0, x_1988);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
-return x_1;
+else
+{
+uint8_t x_1989; lean_object* x_1990; 
+lean_dec(x_1776);
+x_1989 = 1;
+x_1990 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_1990, 0, x_1);
+lean_ctor_set(x_1990, 1, x_2);
+lean_ctor_set(x_1990, 2, x_3);
+lean_ctor_set(x_1990, 3, x_4);
+lean_ctor_set_uint8(x_1990, sizeof(void*)*4, x_1989);
+return x_1990;
 }
 }
 else
 {
-lean_object* x_1989; lean_object* x_1990; lean_object* x_1991; lean_object* x_1992; lean_object* x_1993; lean_object* x_1994; lean_object* x_1995; lean_object* x_1996; lean_object* x_1997; lean_object* x_1998; lean_object* x_1999; lean_object* x_2000; lean_object* x_2001; lean_object* x_2002; lean_object* x_2003; lean_object* x_2004; lean_object* x_2005; 
-x_1989 = lean_ctor_get(x_234, 0);
-x_1990 = lean_ctor_get(x_234, 1);
-x_1991 = lean_ctor_get(x_234, 2);
-x_1992 = lean_ctor_get(x_234, 3);
-lean_inc(x_1992);
-lean_inc(x_1991);
-lean_inc(x_1990);
-lean_inc(x_1989);
-lean_dec(x_234);
-x_1993 = lean_ctor_get(x_4, 1);
-lean_inc(x_1993);
-x_1994 = lean_ctor_get(x_4, 2);
-lean_inc(x_1994);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_1995 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_1995 = lean_box(0);
+uint8_t x_1991; 
+x_1991 = lean_ctor_get_uint8(x_1982, sizeof(void*)*4);
+if (x_1991 == 0)
+{
+uint8_t x_1992; 
+x_1992 = !lean_is_exclusive(x_4);
+if (x_1992 == 0)
+{
+lean_object* x_1993; lean_object* x_1994; uint8_t x_1995; 
+x_1993 = lean_ctor_get(x_4, 3);
+lean_dec(x_1993);
+x_1994 = lean_ctor_get(x_4, 0);
+lean_dec(x_1994);
+x_1995 = !lean_is_exclusive(x_1982);
+if (x_1995 == 0)
+{
+lean_object* x_1996; lean_object* x_1997; lean_object* x_1998; lean_object* x_1999; uint8_t x_2000; uint8_t x_2001; 
+x_1996 = lean_ctor_get(x_1982, 0);
+x_1997 = lean_ctor_get(x_1982, 1);
+x_1998 = lean_ctor_get(x_1982, 2);
+x_1999 = lean_ctor_get(x_1982, 3);
+x_2000 = 1;
+lean_inc(x_1776);
+lean_ctor_set(x_1982, 3, x_1776);
+lean_ctor_set(x_1982, 2, x_3);
+lean_ctor_set(x_1982, 1, x_2);
+lean_ctor_set(x_1982, 0, x_1);
+x_2001 = !lean_is_exclusive(x_1776);
+if (x_2001 == 0)
+{
+lean_object* x_2002; lean_object* x_2003; lean_object* x_2004; lean_object* x_2005; uint8_t x_2006; 
+x_2002 = lean_ctor_get(x_1776, 3);
+lean_dec(x_2002);
+x_2003 = lean_ctor_get(x_1776, 2);
+lean_dec(x_2003);
+x_2004 = lean_ctor_get(x_1776, 1);
+lean_dec(x_2004);
+x_2005 = lean_ctor_get(x_1776, 0);
+lean_dec(x_2005);
+lean_ctor_set_uint8(x_1982, sizeof(void*)*4, x_2000);
+lean_ctor_set(x_1776, 3, x_1999);
+lean_ctor_set(x_1776, 2, x_1998);
+lean_ctor_set(x_1776, 1, x_1997);
+lean_ctor_set(x_1776, 0, x_1996);
+lean_ctor_set_uint8(x_1776, sizeof(void*)*4, x_2000);
+x_2006 = 0;
+lean_ctor_set(x_4, 3, x_1776);
+lean_ctor_set(x_4, 0, x_1982);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2006);
+return x_4;
 }
-x_1996 = lean_ctor_get(x_1891, 0);
-lean_inc(x_1996);
-x_1997 = lean_ctor_get(x_1891, 1);
-lean_inc(x_1997);
-x_1998 = lean_ctor_get(x_1891, 2);
-lean_inc(x_1998);
-x_1999 = lean_ctor_get(x_1891, 3);
-lean_inc(x_1999);
-if (lean_is_exclusive(x_1891)) {
- lean_ctor_release(x_1891, 0);
- lean_ctor_release(x_1891, 1);
- lean_ctor_release(x_1891, 2);
- lean_ctor_release(x_1891, 3);
- x_2000 = x_1891;
-} else {
- lean_dec_ref(x_1891);
- x_2000 = lean_box(0);
-}
-if (lean_is_scalar(x_2000)) {
- x_2001 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2001 = x_2000;
-}
-lean_ctor_set(x_2001, 0, x_1989);
-lean_ctor_set(x_2001, 1, x_1990);
-lean_ctor_set(x_2001, 2, x_1991);
-lean_ctor_set(x_2001, 3, x_1992);
-lean_ctor_set_uint8(x_2001, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-if (lean_is_scalar(x_1995)) {
- x_2002 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2002 = x_1995;
-}
-lean_ctor_set(x_2002, 0, x_2001);
-lean_ctor_set(x_2002, 1, x_1942);
-lean_ctor_set(x_2002, 2, x_1943);
-lean_ctor_set(x_2002, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2003 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2003 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2002, sizeof(void*)*4, x_1940);
-if (lean_is_scalar(x_2003)) {
- x_2004 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2004 = x_2003;
-}
-lean_ctor_set(x_2004, 0, x_2002);
-lean_ctor_set(x_2004, 1, x_2);
-lean_ctor_set(x_2004, 2, x_3);
-lean_ctor_set(x_2004, 3, x_1890);
-lean_ctor_set_uint8(x_2004, sizeof(void*)*4, x_1833);
-x_2005 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2005, 0, x_1996);
-lean_ctor_set(x_2005, 1, x_1997);
-lean_ctor_set(x_2005, 2, x_1998);
-lean_ctor_set(x_2005, 3, x_1999);
-lean_ctor_set_uint8(x_2005, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_2005);
-lean_ctor_set(x_1, 2, x_1994);
-lean_ctor_set(x_1, 1, x_1993);
-lean_ctor_set(x_1, 0, x_2004);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
-return x_1;
+else
+{
+lean_object* x_2007; uint8_t x_2008; 
+lean_dec(x_1776);
+lean_ctor_set_uint8(x_1982, sizeof(void*)*4, x_2000);
+x_2007 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_2007, 0, x_1996);
+lean_ctor_set(x_2007, 1, x_1997);
+lean_ctor_set(x_2007, 2, x_1998);
+lean_ctor_set(x_2007, 3, x_1999);
+lean_ctor_set_uint8(x_2007, sizeof(void*)*4, x_2000);
+x_2008 = 0;
+lean_ctor_set(x_4, 3, x_2007);
+lean_ctor_set(x_4, 0, x_1982);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2008);
+return x_4;
 }
 }
 else
 {
-lean_object* x_2006; lean_object* x_2007; lean_object* x_2008; lean_object* x_2009; lean_object* x_2010; lean_object* x_2011; lean_object* x_2012; lean_object* x_2013; lean_object* x_2014; lean_object* x_2015; lean_object* x_2016; lean_object* x_2017; lean_object* x_2018; lean_object* x_2019; lean_object* x_2020; lean_object* x_2021; lean_object* x_2022; lean_object* x_2023; lean_object* x_2024; lean_object* x_2025; lean_object* x_2026; 
-x_2006 = lean_ctor_get(x_1, 1);
-x_2007 = lean_ctor_get(x_1, 2);
-lean_inc(x_2007);
-lean_inc(x_2006);
-lean_dec(x_1);
-x_2008 = lean_ctor_get(x_234, 0);
-lean_inc(x_2008);
-x_2009 = lean_ctor_get(x_234, 1);
-lean_inc(x_2009);
-x_2010 = lean_ctor_get(x_234, 2);
-lean_inc(x_2010);
-x_2011 = lean_ctor_get(x_234, 3);
+lean_object* x_2009; lean_object* x_2010; lean_object* x_2011; lean_object* x_2012; uint8_t x_2013; lean_object* x_2014; lean_object* x_2015; lean_object* x_2016; uint8_t x_2017; 
+x_2009 = lean_ctor_get(x_1982, 0);
+x_2010 = lean_ctor_get(x_1982, 1);
+x_2011 = lean_ctor_get(x_1982, 2);
+x_2012 = lean_ctor_get(x_1982, 3);
+lean_inc(x_2012);
 lean_inc(x_2011);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2012 = x_234;
+lean_inc(x_2010);
+lean_inc(x_2009);
+lean_dec(x_1982);
+x_2013 = 1;
+lean_inc(x_1776);
+x_2014 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_2014, 0, x_1);
+lean_ctor_set(x_2014, 1, x_2);
+lean_ctor_set(x_2014, 2, x_3);
+lean_ctor_set(x_2014, 3, x_1776);
+if (lean_is_exclusive(x_1776)) {
+ lean_ctor_release(x_1776, 0);
+ lean_ctor_release(x_1776, 1);
+ lean_ctor_release(x_1776, 2);
+ lean_ctor_release(x_1776, 3);
+ x_2015 = x_1776;
 } else {
- lean_dec_ref(x_234);
- x_2012 = lean_box(0);
-}
-x_2013 = lean_ctor_get(x_4, 1);
-lean_inc(x_2013);
-x_2014 = lean_ctor_get(x_4, 2);
-lean_inc(x_2014);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2015 = x_4;
-} else {
- lean_dec_ref(x_4);
+ lean_dec_ref(x_1776);
  x_2015 = lean_box(0);
 }
-x_2016 = lean_ctor_get(x_1891, 0);
-lean_inc(x_2016);
-x_2017 = lean_ctor_get(x_1891, 1);
-lean_inc(x_2017);
-x_2018 = lean_ctor_get(x_1891, 2);
-lean_inc(x_2018);
-x_2019 = lean_ctor_get(x_1891, 3);
-lean_inc(x_2019);
-if (lean_is_exclusive(x_1891)) {
- lean_ctor_release(x_1891, 0);
- lean_ctor_release(x_1891, 1);
- lean_ctor_release(x_1891, 2);
- lean_ctor_release(x_1891, 3);
- x_2020 = x_1891;
-} else {
- lean_dec_ref(x_1891);
- x_2020 = lean_box(0);
-}
-if (lean_is_scalar(x_2020)) {
- x_2021 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2021 = x_2020;
-}
-lean_ctor_set(x_2021, 0, x_2008);
-lean_ctor_set(x_2021, 1, x_2009);
-lean_ctor_set(x_2021, 2, x_2010);
-lean_ctor_set(x_2021, 3, x_2011);
-lean_ctor_set_uint8(x_2021, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
+lean_ctor_set_uint8(x_2014, sizeof(void*)*4, x_2013);
 if (lean_is_scalar(x_2015)) {
- x_2022 = lean_alloc_ctor(1, 4, 1);
+ x_2016 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_2022 = x_2015;
+ x_2016 = x_2015;
 }
-lean_ctor_set(x_2022, 0, x_2021);
-lean_ctor_set(x_2022, 1, x_2006);
-lean_ctor_set(x_2022, 2, x_2007);
-lean_ctor_set(x_2022, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2023 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2023 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2022, sizeof(void*)*4, x_1940);
-if (lean_is_scalar(x_2023)) {
- x_2024 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2024 = x_2023;
-}
-lean_ctor_set(x_2024, 0, x_2022);
-lean_ctor_set(x_2024, 1, x_2);
-lean_ctor_set(x_2024, 2, x_3);
-lean_ctor_set(x_2024, 3, x_1890);
-lean_ctor_set_uint8(x_2024, sizeof(void*)*4, x_1833);
-if (lean_is_scalar(x_2012)) {
- x_2025 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2025 = x_2012;
-}
-lean_ctor_set(x_2025, 0, x_2016);
-lean_ctor_set(x_2025, 1, x_2017);
-lean_ctor_set(x_2025, 2, x_2018);
-lean_ctor_set(x_2025, 3, x_2019);
-lean_ctor_set_uint8(x_2025, sizeof(void*)*4, x_1833);
-x_2026 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2026, 0, x_2024);
-lean_ctor_set(x_2026, 1, x_2013);
-lean_ctor_set(x_2026, 2, x_2014);
-lean_ctor_set(x_2026, 3, x_2025);
-lean_ctor_set_uint8(x_2026, sizeof(void*)*4, x_1940);
-return x_2026;
+lean_ctor_set(x_2016, 0, x_2009);
+lean_ctor_set(x_2016, 1, x_2010);
+lean_ctor_set(x_2016, 2, x_2011);
+lean_ctor_set(x_2016, 3, x_2012);
+lean_ctor_set_uint8(x_2016, sizeof(void*)*4, x_2013);
+x_2017 = 0;
+lean_ctor_set(x_4, 3, x_2016);
+lean_ctor_set(x_4, 0, x_2014);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2017);
+return x_4;
 }
 }
 else
 {
-uint8_t x_2027; 
-x_2027 = !lean_is_exclusive(x_1891);
-if (x_2027 == 0)
+lean_object* x_2018; lean_object* x_2019; lean_object* x_2020; lean_object* x_2021; lean_object* x_2022; lean_object* x_2023; lean_object* x_2024; uint8_t x_2025; lean_object* x_2026; lean_object* x_2027; lean_object* x_2028; uint8_t x_2029; lean_object* x_2030; 
+x_2018 = lean_ctor_get(x_4, 1);
+x_2019 = lean_ctor_get(x_4, 2);
+lean_inc(x_2019);
+lean_inc(x_2018);
+lean_dec(x_4);
+x_2020 = lean_ctor_get(x_1982, 0);
+lean_inc(x_2020);
+x_2021 = lean_ctor_get(x_1982, 1);
+lean_inc(x_2021);
+x_2022 = lean_ctor_get(x_1982, 2);
+lean_inc(x_2022);
+x_2023 = lean_ctor_get(x_1982, 3);
+lean_inc(x_2023);
+if (lean_is_exclusive(x_1982)) {
+ lean_ctor_release(x_1982, 0);
+ lean_ctor_release(x_1982, 1);
+ lean_ctor_release(x_1982, 2);
+ lean_ctor_release(x_1982, 3);
+ x_2024 = x_1982;
+} else {
+ lean_dec_ref(x_1982);
+ x_2024 = lean_box(0);
+}
+x_2025 = 1;
+lean_inc(x_1776);
+if (lean_is_scalar(x_2024)) {
+ x_2026 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_2026 = x_2024;
+}
+lean_ctor_set(x_2026, 0, x_1);
+lean_ctor_set(x_2026, 1, x_2);
+lean_ctor_set(x_2026, 2, x_3);
+lean_ctor_set(x_2026, 3, x_1776);
+if (lean_is_exclusive(x_1776)) {
+ lean_ctor_release(x_1776, 0);
+ lean_ctor_release(x_1776, 1);
+ lean_ctor_release(x_1776, 2);
+ lean_ctor_release(x_1776, 3);
+ x_2027 = x_1776;
+} else {
+ lean_dec_ref(x_1776);
+ x_2027 = lean_box(0);
+}
+lean_ctor_set_uint8(x_2026, sizeof(void*)*4, x_2025);
+if (lean_is_scalar(x_2027)) {
+ x_2028 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_2028 = x_2027;
+}
+lean_ctor_set(x_2028, 0, x_2020);
+lean_ctor_set(x_2028, 1, x_2021);
+lean_ctor_set(x_2028, 2, x_2022);
+lean_ctor_set(x_2028, 3, x_2023);
+lean_ctor_set_uint8(x_2028, sizeof(void*)*4, x_2025);
+x_2029 = 0;
+x_2030 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_2030, 0, x_2026);
+lean_ctor_set(x_2030, 1, x_2018);
+lean_ctor_set(x_2030, 2, x_2019);
+lean_ctor_set(x_2030, 3, x_2028);
+lean_ctor_set_uint8(x_2030, sizeof(void*)*4, x_2029);
+return x_2030;
+}
+}
+else
 {
-lean_object* x_2028; lean_object* x_2029; lean_object* x_2030; lean_object* x_2031; uint8_t x_2032; 
-x_2028 = lean_ctor_get(x_1891, 3);
-lean_dec(x_2028);
-x_2029 = lean_ctor_get(x_1891, 2);
-lean_dec(x_2029);
-x_2030 = lean_ctor_get(x_1891, 1);
-lean_dec(x_2030);
-x_2031 = lean_ctor_get(x_1891, 0);
-lean_dec(x_2031);
-x_2032 = !lean_is_exclusive(x_1);
-if (x_2032 == 0)
+uint8_t x_2031; 
+lean_dec(x_1776);
+x_2031 = !lean_is_exclusive(x_1982);
+if (x_2031 == 0)
 {
-lean_object* x_2033; lean_object* x_2034; lean_object* x_2035; lean_object* x_2036; uint8_t x_2037; 
-x_2033 = lean_ctor_get(x_1, 1);
-x_2034 = lean_ctor_get(x_1, 2);
-x_2035 = lean_ctor_get(x_1, 3);
+lean_object* x_2032; lean_object* x_2033; lean_object* x_2034; lean_object* x_2035; uint8_t x_2036; 
+x_2032 = lean_ctor_get(x_1982, 3);
+lean_dec(x_2032);
+x_2033 = lean_ctor_get(x_1982, 2);
+lean_dec(x_2033);
+x_2034 = lean_ctor_get(x_1982, 1);
+lean_dec(x_2034);
+x_2035 = lean_ctor_get(x_1982, 0);
 lean_dec(x_2035);
-x_2036 = lean_ctor_get(x_1, 0);
-lean_dec(x_2036);
-x_2037 = !lean_is_exclusive(x_234);
-if (x_2037 == 0)
-{
-uint8_t x_2038; 
-x_2038 = !lean_is_exclusive(x_1265);
-if (x_2038 == 0)
-{
-lean_object* x_2039; lean_object* x_2040; lean_object* x_2041; lean_object* x_2042; 
-x_2039 = lean_ctor_get(x_234, 0);
-x_2040 = lean_ctor_get(x_234, 1);
-x_2041 = lean_ctor_get(x_234, 2);
-x_2042 = lean_ctor_get(x_234, 3);
-lean_ctor_set(x_1891, 3, x_2042);
-lean_ctor_set(x_1891, 2, x_2041);
-lean_ctor_set(x_1891, 1, x_2040);
-lean_ctor_set(x_1891, 0, x_2039);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1940);
-lean_ctor_set(x_234, 3, x_1265);
-lean_ctor_set(x_234, 2, x_2034);
-lean_ctor_set(x_234, 1, x_2033);
-lean_ctor_set(x_234, 0, x_1891);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
-return x_1;
-}
-else
-{
-lean_object* x_2043; lean_object* x_2044; lean_object* x_2045; lean_object* x_2046; lean_object* x_2047; lean_object* x_2048; lean_object* x_2049; lean_object* x_2050; lean_object* x_2051; 
-x_2043 = lean_ctor_get(x_234, 0);
-x_2044 = lean_ctor_get(x_234, 1);
-x_2045 = lean_ctor_get(x_234, 2);
-x_2046 = lean_ctor_get(x_234, 3);
-x_2047 = lean_ctor_get(x_1265, 0);
-x_2048 = lean_ctor_get(x_1265, 1);
-x_2049 = lean_ctor_get(x_1265, 2);
-x_2050 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2050);
-lean_inc(x_2049);
-lean_inc(x_2048);
-lean_inc(x_2047);
-lean_dec(x_1265);
-lean_ctor_set(x_1891, 3, x_2046);
-lean_ctor_set(x_1891, 2, x_2045);
-lean_ctor_set(x_1891, 1, x_2044);
-lean_ctor_set(x_1891, 0, x_2043);
-x_2051 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2051, 0, x_2047);
-lean_ctor_set(x_2051, 1, x_2048);
-lean_ctor_set(x_2051, 2, x_2049);
-lean_ctor_set(x_2051, 3, x_2050);
-lean_ctor_set_uint8(x_2051, sizeof(void*)*4, x_1940);
-lean_ctor_set(x_234, 3, x_2051);
-lean_ctor_set(x_234, 2, x_2034);
-lean_ctor_set(x_234, 1, x_2033);
-lean_ctor_set(x_234, 0, x_1891);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2052; lean_object* x_2053; lean_object* x_2054; lean_object* x_2055; lean_object* x_2056; lean_object* x_2057; lean_object* x_2058; lean_object* x_2059; lean_object* x_2060; lean_object* x_2061; lean_object* x_2062; 
-x_2052 = lean_ctor_get(x_234, 0);
-x_2053 = lean_ctor_get(x_234, 1);
-x_2054 = lean_ctor_get(x_234, 2);
-x_2055 = lean_ctor_get(x_234, 3);
-lean_inc(x_2055);
-lean_inc(x_2054);
-lean_inc(x_2053);
-lean_inc(x_2052);
-lean_dec(x_234);
-x_2056 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2056);
-x_2057 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2057);
-x_2058 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2058);
-x_2059 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2059);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2060 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2060 = lean_box(0);
-}
-lean_ctor_set(x_1891, 3, x_2055);
-lean_ctor_set(x_1891, 2, x_2054);
-lean_ctor_set(x_1891, 1, x_2053);
-lean_ctor_set(x_1891, 0, x_2052);
-if (lean_is_scalar(x_2060)) {
- x_2061 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2061 = x_2060;
-}
-lean_ctor_set(x_2061, 0, x_2056);
-lean_ctor_set(x_2061, 1, x_2057);
-lean_ctor_set(x_2061, 2, x_2058);
-lean_ctor_set(x_2061, 3, x_2059);
-lean_ctor_set_uint8(x_2061, sizeof(void*)*4, x_1940);
-x_2062 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2062, 0, x_1891);
-lean_ctor_set(x_2062, 1, x_2033);
-lean_ctor_set(x_2062, 2, x_2034);
-lean_ctor_set(x_2062, 3, x_2061);
-lean_ctor_set_uint8(x_2062, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_2062);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1940);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2063; lean_object* x_2064; lean_object* x_2065; lean_object* x_2066; lean_object* x_2067; lean_object* x_2068; lean_object* x_2069; lean_object* x_2070; lean_object* x_2071; lean_object* x_2072; lean_object* x_2073; lean_object* x_2074; lean_object* x_2075; lean_object* x_2076; lean_object* x_2077; 
-x_2063 = lean_ctor_get(x_1, 1);
-x_2064 = lean_ctor_get(x_1, 2);
-lean_inc(x_2064);
-lean_inc(x_2063);
-lean_dec(x_1);
-x_2065 = lean_ctor_get(x_234, 0);
-lean_inc(x_2065);
-x_2066 = lean_ctor_get(x_234, 1);
-lean_inc(x_2066);
-x_2067 = lean_ctor_get(x_234, 2);
-lean_inc(x_2067);
-x_2068 = lean_ctor_get(x_234, 3);
-lean_inc(x_2068);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2069 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2069 = lean_box(0);
-}
-x_2070 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2070);
-x_2071 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2071);
-x_2072 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2072);
-x_2073 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2073);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2074 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2074 = lean_box(0);
-}
-lean_ctor_set(x_1891, 3, x_2068);
-lean_ctor_set(x_1891, 2, x_2067);
-lean_ctor_set(x_1891, 1, x_2066);
-lean_ctor_set(x_1891, 0, x_2065);
-if (lean_is_scalar(x_2074)) {
- x_2075 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2075 = x_2074;
-}
-lean_ctor_set(x_2075, 0, x_2070);
-lean_ctor_set(x_2075, 1, x_2071);
-lean_ctor_set(x_2075, 2, x_2072);
-lean_ctor_set(x_2075, 3, x_2073);
-lean_ctor_set_uint8(x_2075, sizeof(void*)*4, x_1940);
-if (lean_is_scalar(x_2069)) {
- x_2076 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2076 = x_2069;
-}
-lean_ctor_set(x_2076, 0, x_1891);
-lean_ctor_set(x_2076, 1, x_2063);
-lean_ctor_set(x_2076, 2, x_2064);
-lean_ctor_set(x_2076, 3, x_2075);
-lean_ctor_set_uint8(x_2076, sizeof(void*)*4, x_1889);
-x_2077 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2077, 0, x_2076);
-lean_ctor_set(x_2077, 1, x_2);
-lean_ctor_set(x_2077, 2, x_3);
-lean_ctor_set(x_2077, 3, x_4);
-lean_ctor_set_uint8(x_2077, sizeof(void*)*4, x_1940);
-return x_2077;
-}
-}
-else
-{
-lean_object* x_2078; lean_object* x_2079; lean_object* x_2080; lean_object* x_2081; lean_object* x_2082; lean_object* x_2083; lean_object* x_2084; lean_object* x_2085; lean_object* x_2086; lean_object* x_2087; lean_object* x_2088; lean_object* x_2089; lean_object* x_2090; lean_object* x_2091; lean_object* x_2092; lean_object* x_2093; lean_object* x_2094; 
-lean_dec(x_1891);
-x_2078 = lean_ctor_get(x_1, 1);
-lean_inc(x_2078);
-x_2079 = lean_ctor_get(x_1, 2);
-lean_inc(x_2079);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2080 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2080 = lean_box(0);
-}
-x_2081 = lean_ctor_get(x_234, 0);
-lean_inc(x_2081);
-x_2082 = lean_ctor_get(x_234, 1);
-lean_inc(x_2082);
-x_2083 = lean_ctor_get(x_234, 2);
-lean_inc(x_2083);
-x_2084 = lean_ctor_get(x_234, 3);
-lean_inc(x_2084);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2085 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2085 = lean_box(0);
-}
-x_2086 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2086);
-x_2087 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2087);
-x_2088 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2088);
-x_2089 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2089);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2090 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2090 = lean_box(0);
-}
-x_2091 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2091, 0, x_2081);
-lean_ctor_set(x_2091, 1, x_2082);
-lean_ctor_set(x_2091, 2, x_2083);
-lean_ctor_set(x_2091, 3, x_2084);
-lean_ctor_set_uint8(x_2091, sizeof(void*)*4, x_1940);
-if (lean_is_scalar(x_2090)) {
- x_2092 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2092 = x_2090;
-}
-lean_ctor_set(x_2092, 0, x_2086);
-lean_ctor_set(x_2092, 1, x_2087);
-lean_ctor_set(x_2092, 2, x_2088);
-lean_ctor_set(x_2092, 3, x_2089);
-lean_ctor_set_uint8(x_2092, sizeof(void*)*4, x_1940);
-if (lean_is_scalar(x_2085)) {
- x_2093 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2093 = x_2085;
-}
-lean_ctor_set(x_2093, 0, x_2091);
-lean_ctor_set(x_2093, 1, x_2078);
-lean_ctor_set(x_2093, 2, x_2079);
-lean_ctor_set(x_2093, 3, x_2092);
-lean_ctor_set_uint8(x_2093, sizeof(void*)*4, x_1889);
-if (lean_is_scalar(x_2080)) {
- x_2094 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2094 = x_2080;
-}
-lean_ctor_set(x_2094, 0, x_2093);
-lean_ctor_set(x_2094, 1, x_2);
-lean_ctor_set(x_2094, 2, x_3);
-lean_ctor_set(x_2094, 3, x_4);
-lean_ctor_set_uint8(x_2094, sizeof(void*)*4, x_1940);
-return x_2094;
-}
-}
-}
-}
-else
-{
-uint8_t x_2095; 
-x_2095 = lean_ctor_get_uint8(x_1890, sizeof(void*)*4);
-if (x_2095 == 0)
-{
-lean_object* x_2096; 
-x_2096 = lean_ctor_get(x_4, 3);
-lean_inc(x_2096);
-if (lean_obj_tag(x_2096) == 0)
-{
-uint8_t x_2097; 
-x_2097 = !lean_is_exclusive(x_1);
-if (x_2097 == 0)
-{
-lean_object* x_2098; lean_object* x_2099; lean_object* x_2100; lean_object* x_2101; uint8_t x_2102; 
-x_2098 = lean_ctor_get(x_1, 1);
-x_2099 = lean_ctor_get(x_1, 2);
-x_2100 = lean_ctor_get(x_1, 3);
-lean_dec(x_2100);
-x_2101 = lean_ctor_get(x_1, 0);
-lean_dec(x_2101);
-x_2102 = !lean_is_exclusive(x_234);
-if (x_2102 == 0)
-{
-uint8_t x_2103; 
-x_2103 = !lean_is_exclusive(x_4);
-if (x_2103 == 0)
-{
-lean_object* x_2104; lean_object* x_2105; lean_object* x_2106; lean_object* x_2107; lean_object* x_2108; lean_object* x_2109; lean_object* x_2110; lean_object* x_2111; uint8_t x_2112; 
-x_2104 = lean_ctor_get(x_234, 0);
-x_2105 = lean_ctor_get(x_234, 1);
-x_2106 = lean_ctor_get(x_234, 2);
-x_2107 = lean_ctor_get(x_234, 3);
-x_2108 = lean_ctor_get(x_4, 1);
-x_2109 = lean_ctor_get(x_4, 2);
-x_2110 = lean_ctor_get(x_4, 3);
-lean_dec(x_2110);
-x_2111 = lean_ctor_get(x_4, 0);
-lean_dec(x_2111);
-x_2112 = !lean_is_exclusive(x_1890);
-if (x_2112 == 0)
-{
-lean_object* x_2113; lean_object* x_2114; lean_object* x_2115; lean_object* x_2116; uint8_t x_2117; 
-x_2113 = lean_ctor_get(x_1890, 0);
-x_2114 = lean_ctor_get(x_1890, 1);
-x_2115 = lean_ctor_get(x_1890, 2);
-x_2116 = lean_ctor_get(x_1890, 3);
-lean_ctor_set(x_1890, 3, x_2107);
-lean_ctor_set(x_1890, 2, x_2106);
-lean_ctor_set(x_1890, 1, x_2105);
-lean_ctor_set(x_1890, 0, x_2104);
-lean_ctor_set_uint8(x_1890, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_2099);
-lean_ctor_set(x_4, 1, x_2098);
-x_2117 = !lean_is_exclusive(x_1265);
-if (x_2117 == 0)
-{
-lean_object* x_2118; lean_object* x_2119; lean_object* x_2120; lean_object* x_2121; 
-x_2118 = lean_ctor_get(x_1265, 3);
-lean_dec(x_2118);
-x_2119 = lean_ctor_get(x_1265, 2);
-lean_dec(x_2119);
-x_2120 = lean_ctor_get(x_1265, 1);
-lean_dec(x_2120);
-x_2121 = lean_ctor_get(x_1265, 0);
-lean_dec(x_2121);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1265, 3, x_2113);
-lean_ctor_set(x_1265, 2, x_3);
-lean_ctor_set(x_1265, 1, x_2);
-lean_ctor_set(x_1265, 0, x_4);
-lean_ctor_set(x_234, 3, x_2096);
-lean_ctor_set(x_234, 2, x_2109);
-lean_ctor_set(x_234, 1, x_2108);
-lean_ctor_set(x_234, 0, x_2116);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2115);
-lean_ctor_set(x_1, 1, x_2114);
-lean_ctor_set(x_1, 0, x_1265);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-else
-{
-lean_object* x_2122; 
-lean_dec(x_1265);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2095);
-x_2122 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2122, 0, x_4);
-lean_ctor_set(x_2122, 1, x_2);
-lean_ctor_set(x_2122, 2, x_3);
-lean_ctor_set(x_2122, 3, x_2113);
-lean_ctor_set_uint8(x_2122, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_2096);
-lean_ctor_set(x_234, 2, x_2109);
-lean_ctor_set(x_234, 1, x_2108);
-lean_ctor_set(x_234, 0, x_2116);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2115);
-lean_ctor_set(x_1, 1, x_2114);
-lean_ctor_set(x_1, 0, x_2122);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2123; lean_object* x_2124; lean_object* x_2125; lean_object* x_2126; lean_object* x_2127; lean_object* x_2128; lean_object* x_2129; 
-x_2123 = lean_ctor_get(x_1890, 0);
-x_2124 = lean_ctor_get(x_1890, 1);
-x_2125 = lean_ctor_get(x_1890, 2);
-x_2126 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2126);
-lean_inc(x_2125);
-lean_inc(x_2124);
-lean_inc(x_2123);
-lean_dec(x_1890);
-x_2127 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2127, 0, x_2104);
-lean_ctor_set(x_2127, 1, x_2105);
-lean_ctor_set(x_2127, 2, x_2106);
-lean_ctor_set(x_2127, 3, x_2107);
-lean_ctor_set_uint8(x_2127, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-lean_ctor_set(x_4, 3, x_1265);
-lean_ctor_set(x_4, 2, x_2099);
-lean_ctor_set(x_4, 1, x_2098);
-lean_ctor_set(x_4, 0, x_2127);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2128 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2128 = lean_box(0);
-}
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2128)) {
- x_2129 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2129 = x_2128;
-}
-lean_ctor_set(x_2129, 0, x_4);
-lean_ctor_set(x_2129, 1, x_2);
-lean_ctor_set(x_2129, 2, x_3);
-lean_ctor_set(x_2129, 3, x_2123);
-lean_ctor_set_uint8(x_2129, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_2096);
-lean_ctor_set(x_234, 2, x_2109);
-lean_ctor_set(x_234, 1, x_2108);
-lean_ctor_set(x_234, 0, x_2126);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2125);
-lean_ctor_set(x_1, 1, x_2124);
-lean_ctor_set(x_1, 0, x_2129);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2130; lean_object* x_2131; lean_object* x_2132; lean_object* x_2133; lean_object* x_2134; lean_object* x_2135; lean_object* x_2136; lean_object* x_2137; lean_object* x_2138; lean_object* x_2139; lean_object* x_2140; lean_object* x_2141; lean_object* x_2142; lean_object* x_2143; lean_object* x_2144; 
-x_2130 = lean_ctor_get(x_234, 0);
-x_2131 = lean_ctor_get(x_234, 1);
-x_2132 = lean_ctor_get(x_234, 2);
-x_2133 = lean_ctor_get(x_234, 3);
-x_2134 = lean_ctor_get(x_4, 1);
-x_2135 = lean_ctor_get(x_4, 2);
-lean_inc(x_2135);
-lean_inc(x_2134);
-lean_dec(x_4);
-x_2136 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2136);
-x_2137 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2137);
-x_2138 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2138);
-x_2139 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2139);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2140 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2140 = lean_box(0);
-}
-if (lean_is_scalar(x_2140)) {
- x_2141 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2141 = x_2140;
-}
-lean_ctor_set(x_2141, 0, x_2130);
-lean_ctor_set(x_2141, 1, x_2131);
-lean_ctor_set(x_2141, 2, x_2132);
-lean_ctor_set(x_2141, 3, x_2133);
-lean_ctor_set_uint8(x_2141, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-x_2142 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2142, 0, x_2141);
-lean_ctor_set(x_2142, 1, x_2098);
-lean_ctor_set(x_2142, 2, x_2099);
-lean_ctor_set(x_2142, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2143 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2143 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2142, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2143)) {
- x_2144 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2144 = x_2143;
-}
-lean_ctor_set(x_2144, 0, x_2142);
-lean_ctor_set(x_2144, 1, x_2);
-lean_ctor_set(x_2144, 2, x_3);
-lean_ctor_set(x_2144, 3, x_2136);
-lean_ctor_set_uint8(x_2144, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_2096);
-lean_ctor_set(x_234, 2, x_2135);
-lean_ctor_set(x_234, 1, x_2134);
-lean_ctor_set(x_234, 0, x_2139);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2138);
-lean_ctor_set(x_1, 1, x_2137);
-lean_ctor_set(x_1, 0, x_2144);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2145; lean_object* x_2146; lean_object* x_2147; lean_object* x_2148; lean_object* x_2149; lean_object* x_2150; lean_object* x_2151; lean_object* x_2152; lean_object* x_2153; lean_object* x_2154; lean_object* x_2155; lean_object* x_2156; lean_object* x_2157; lean_object* x_2158; lean_object* x_2159; lean_object* x_2160; lean_object* x_2161; 
-x_2145 = lean_ctor_get(x_234, 0);
-x_2146 = lean_ctor_get(x_234, 1);
-x_2147 = lean_ctor_get(x_234, 2);
-x_2148 = lean_ctor_get(x_234, 3);
-lean_inc(x_2148);
-lean_inc(x_2147);
-lean_inc(x_2146);
-lean_inc(x_2145);
-lean_dec(x_234);
-x_2149 = lean_ctor_get(x_4, 1);
-lean_inc(x_2149);
-x_2150 = lean_ctor_get(x_4, 2);
-lean_inc(x_2150);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2151 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2151 = lean_box(0);
-}
-x_2152 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2152);
-x_2153 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2153);
-x_2154 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2154);
-x_2155 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2155);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2156 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2156 = lean_box(0);
-}
-if (lean_is_scalar(x_2156)) {
- x_2157 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2157 = x_2156;
-}
-lean_ctor_set(x_2157, 0, x_2145);
-lean_ctor_set(x_2157, 1, x_2146);
-lean_ctor_set(x_2157, 2, x_2147);
-lean_ctor_set(x_2157, 3, x_2148);
-lean_ctor_set_uint8(x_2157, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-if (lean_is_scalar(x_2151)) {
- x_2158 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2158 = x_2151;
-}
-lean_ctor_set(x_2158, 0, x_2157);
-lean_ctor_set(x_2158, 1, x_2098);
-lean_ctor_set(x_2158, 2, x_2099);
-lean_ctor_set(x_2158, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2159 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2159 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2158, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2159)) {
- x_2160 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2160 = x_2159;
-}
-lean_ctor_set(x_2160, 0, x_2158);
-lean_ctor_set(x_2160, 1, x_2);
-lean_ctor_set(x_2160, 2, x_3);
-lean_ctor_set(x_2160, 3, x_2152);
-lean_ctor_set_uint8(x_2160, sizeof(void*)*4, x_1833);
-x_2161 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2161, 0, x_2155);
-lean_ctor_set(x_2161, 1, x_2149);
-lean_ctor_set(x_2161, 2, x_2150);
-lean_ctor_set(x_2161, 3, x_2096);
-lean_ctor_set_uint8(x_2161, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_2161);
-lean_ctor_set(x_1, 2, x_2154);
-lean_ctor_set(x_1, 1, x_2153);
-lean_ctor_set(x_1, 0, x_2160);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2162; lean_object* x_2163; lean_object* x_2164; lean_object* x_2165; lean_object* x_2166; lean_object* x_2167; lean_object* x_2168; lean_object* x_2169; lean_object* x_2170; lean_object* x_2171; lean_object* x_2172; lean_object* x_2173; lean_object* x_2174; lean_object* x_2175; lean_object* x_2176; lean_object* x_2177; lean_object* x_2178; lean_object* x_2179; lean_object* x_2180; lean_object* x_2181; lean_object* x_2182; 
-x_2162 = lean_ctor_get(x_1, 1);
-x_2163 = lean_ctor_get(x_1, 2);
-lean_inc(x_2163);
-lean_inc(x_2162);
-lean_dec(x_1);
-x_2164 = lean_ctor_get(x_234, 0);
-lean_inc(x_2164);
-x_2165 = lean_ctor_get(x_234, 1);
-lean_inc(x_2165);
-x_2166 = lean_ctor_get(x_234, 2);
-lean_inc(x_2166);
-x_2167 = lean_ctor_get(x_234, 3);
-lean_inc(x_2167);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2168 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2168 = lean_box(0);
-}
-x_2169 = lean_ctor_get(x_4, 1);
-lean_inc(x_2169);
-x_2170 = lean_ctor_get(x_4, 2);
-lean_inc(x_2170);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2171 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2171 = lean_box(0);
-}
-x_2172 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2172);
-x_2173 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2173);
-x_2174 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2174);
-x_2175 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2175);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2176 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2176 = lean_box(0);
-}
-if (lean_is_scalar(x_2176)) {
- x_2177 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2177 = x_2176;
-}
-lean_ctor_set(x_2177, 0, x_2164);
-lean_ctor_set(x_2177, 1, x_2165);
-lean_ctor_set(x_2177, 2, x_2166);
-lean_ctor_set(x_2177, 3, x_2167);
-lean_ctor_set_uint8(x_2177, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-if (lean_is_scalar(x_2171)) {
- x_2178 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2178 = x_2171;
-}
-lean_ctor_set(x_2178, 0, x_2177);
-lean_ctor_set(x_2178, 1, x_2162);
-lean_ctor_set(x_2178, 2, x_2163);
-lean_ctor_set(x_2178, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2179 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2179 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2178, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2179)) {
- x_2180 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2180 = x_2179;
-}
-lean_ctor_set(x_2180, 0, x_2178);
-lean_ctor_set(x_2180, 1, x_2);
-lean_ctor_set(x_2180, 2, x_3);
-lean_ctor_set(x_2180, 3, x_2172);
-lean_ctor_set_uint8(x_2180, sizeof(void*)*4, x_1833);
-if (lean_is_scalar(x_2168)) {
- x_2181 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2181 = x_2168;
-}
-lean_ctor_set(x_2181, 0, x_2175);
-lean_ctor_set(x_2181, 1, x_2169);
-lean_ctor_set(x_2181, 2, x_2170);
-lean_ctor_set(x_2181, 3, x_2096);
-lean_ctor_set_uint8(x_2181, sizeof(void*)*4, x_1833);
-x_2182 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2182, 0, x_2180);
-lean_ctor_set(x_2182, 1, x_2173);
-lean_ctor_set(x_2182, 2, x_2174);
-lean_ctor_set(x_2182, 3, x_2181);
-lean_ctor_set_uint8(x_2182, sizeof(void*)*4, x_2095);
-return x_2182;
-}
-}
-else
-{
-uint8_t x_2183; 
-x_2183 = lean_ctor_get_uint8(x_2096, sizeof(void*)*4);
-if (x_2183 == 0)
-{
-uint8_t x_2184; 
-x_2184 = !lean_is_exclusive(x_1);
-if (x_2184 == 0)
-{
-lean_object* x_2185; lean_object* x_2186; lean_object* x_2187; lean_object* x_2188; uint8_t x_2189; 
-x_2185 = lean_ctor_get(x_1, 1);
-x_2186 = lean_ctor_get(x_1, 2);
-x_2187 = lean_ctor_get(x_1, 3);
-lean_dec(x_2187);
-x_2188 = lean_ctor_get(x_1, 0);
-lean_dec(x_2188);
-x_2189 = !lean_is_exclusive(x_234);
-if (x_2189 == 0)
-{
-uint8_t x_2190; 
-x_2190 = !lean_is_exclusive(x_4);
-if (x_2190 == 0)
-{
-lean_object* x_2191; lean_object* x_2192; lean_object* x_2193; lean_object* x_2194; lean_object* x_2195; lean_object* x_2196; lean_object* x_2197; lean_object* x_2198; uint8_t x_2199; 
-x_2191 = lean_ctor_get(x_234, 0);
-x_2192 = lean_ctor_get(x_234, 1);
-x_2193 = lean_ctor_get(x_234, 2);
-x_2194 = lean_ctor_get(x_234, 3);
-x_2195 = lean_ctor_get(x_4, 1);
-x_2196 = lean_ctor_get(x_4, 2);
-x_2197 = lean_ctor_get(x_4, 3);
-lean_dec(x_2197);
-x_2198 = lean_ctor_get(x_4, 0);
-lean_dec(x_2198);
-x_2199 = !lean_is_exclusive(x_1890);
-if (x_2199 == 0)
-{
-uint8_t x_2200; 
-x_2200 = !lean_is_exclusive(x_2096);
-if (x_2200 == 0)
-{
-lean_object* x_2201; lean_object* x_2202; lean_object* x_2203; lean_object* x_2204; lean_object* x_2205; lean_object* x_2206; lean_object* x_2207; lean_object* x_2208; uint8_t x_2209; 
-x_2201 = lean_ctor_get(x_1890, 0);
-x_2202 = lean_ctor_get(x_1890, 1);
-x_2203 = lean_ctor_get(x_1890, 2);
-x_2204 = lean_ctor_get(x_1890, 3);
-x_2205 = lean_ctor_get(x_2096, 0);
-x_2206 = lean_ctor_get(x_2096, 1);
-x_2207 = lean_ctor_get(x_2096, 2);
-x_2208 = lean_ctor_get(x_2096, 3);
-lean_ctor_set(x_2096, 3, x_2194);
-lean_ctor_set(x_2096, 2, x_2193);
-lean_ctor_set(x_2096, 1, x_2192);
-lean_ctor_set(x_2096, 0, x_2191);
-lean_ctor_set_uint8(x_2096, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-lean_ctor_set(x_1890, 3, x_1265);
-lean_ctor_set(x_1890, 2, x_2186);
-lean_ctor_set(x_1890, 1, x_2185);
-lean_ctor_set(x_1890, 0, x_2096);
-x_2209 = !lean_is_exclusive(x_1265);
-if (x_2209 == 0)
-{
-lean_object* x_2210; lean_object* x_2211; lean_object* x_2212; lean_object* x_2213; 
-x_2210 = lean_ctor_get(x_1265, 3);
-lean_dec(x_2210);
-x_2211 = lean_ctor_get(x_1265, 2);
-lean_dec(x_2211);
-x_2212 = lean_ctor_get(x_1265, 1);
-lean_dec(x_2212);
-x_2213 = lean_ctor_get(x_1265, 0);
-lean_dec(x_2213);
-lean_ctor_set_uint8(x_1890, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_4, 3, x_2204);
-lean_ctor_set(x_4, 2, x_2203);
-lean_ctor_set(x_4, 1, x_2202);
-lean_ctor_set(x_4, 0, x_2201);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1265, 3, x_4);
-lean_ctor_set(x_1265, 2, x_3);
-lean_ctor_set(x_1265, 1, x_2);
-lean_ctor_set(x_1265, 0, x_1890);
-lean_ctor_set(x_234, 3, x_2208);
-lean_ctor_set(x_234, 2, x_2207);
-lean_ctor_set(x_234, 1, x_2206);
-lean_ctor_set(x_234, 0, x_2205);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2196);
-lean_ctor_set(x_1, 1, x_2195);
-lean_ctor_set(x_1, 0, x_1265);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-return x_1;
-}
-else
-{
-lean_object* x_2214; 
-lean_dec(x_1265);
-lean_ctor_set_uint8(x_1890, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_4, 3, x_2204);
-lean_ctor_set(x_4, 2, x_2203);
-lean_ctor_set(x_4, 1, x_2202);
-lean_ctor_set(x_4, 0, x_2201);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2183);
-x_2214 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2214, 0, x_1890);
-lean_ctor_set(x_2214, 1, x_2);
-lean_ctor_set(x_2214, 2, x_3);
-lean_ctor_set(x_2214, 3, x_4);
-lean_ctor_set_uint8(x_2214, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_2208);
-lean_ctor_set(x_234, 2, x_2207);
-lean_ctor_set(x_234, 1, x_2206);
-lean_ctor_set(x_234, 0, x_2205);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2196);
-lean_ctor_set(x_1, 1, x_2195);
-lean_ctor_set(x_1, 0, x_2214);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2215; lean_object* x_2216; lean_object* x_2217; lean_object* x_2218; lean_object* x_2219; lean_object* x_2220; lean_object* x_2221; lean_object* x_2222; lean_object* x_2223; lean_object* x_2224; lean_object* x_2225; 
-x_2215 = lean_ctor_get(x_1890, 0);
-x_2216 = lean_ctor_get(x_1890, 1);
-x_2217 = lean_ctor_get(x_1890, 2);
-x_2218 = lean_ctor_get(x_1890, 3);
-x_2219 = lean_ctor_get(x_2096, 0);
-x_2220 = lean_ctor_get(x_2096, 1);
-x_2221 = lean_ctor_get(x_2096, 2);
-x_2222 = lean_ctor_get(x_2096, 3);
-lean_inc(x_2222);
-lean_inc(x_2221);
-lean_inc(x_2220);
-lean_inc(x_2219);
-lean_dec(x_2096);
-x_2223 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2223, 0, x_2191);
-lean_ctor_set(x_2223, 1, x_2192);
-lean_ctor_set(x_2223, 2, x_2193);
-lean_ctor_set(x_2223, 3, x_2194);
-lean_ctor_set_uint8(x_2223, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-lean_ctor_set(x_1890, 3, x_1265);
-lean_ctor_set(x_1890, 2, x_2186);
-lean_ctor_set(x_1890, 1, x_2185);
-lean_ctor_set(x_1890, 0, x_2223);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2224 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2224 = lean_box(0);
-}
-lean_ctor_set_uint8(x_1890, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_4, 3, x_2218);
-lean_ctor_set(x_4, 2, x_2217);
-lean_ctor_set(x_4, 1, x_2216);
-lean_ctor_set(x_4, 0, x_2215);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2224)) {
- x_2225 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2225 = x_2224;
-}
-lean_ctor_set(x_2225, 0, x_1890);
-lean_ctor_set(x_2225, 1, x_2);
-lean_ctor_set(x_2225, 2, x_3);
-lean_ctor_set(x_2225, 3, x_4);
-lean_ctor_set_uint8(x_2225, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_2222);
-lean_ctor_set(x_234, 2, x_2221);
-lean_ctor_set(x_234, 1, x_2220);
-lean_ctor_set(x_234, 0, x_2219);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2196);
-lean_ctor_set(x_1, 1, x_2195);
-lean_ctor_set(x_1, 0, x_2225);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2226; lean_object* x_2227; lean_object* x_2228; lean_object* x_2229; lean_object* x_2230; lean_object* x_2231; lean_object* x_2232; lean_object* x_2233; lean_object* x_2234; lean_object* x_2235; lean_object* x_2236; lean_object* x_2237; lean_object* x_2238; 
-x_2226 = lean_ctor_get(x_1890, 0);
-x_2227 = lean_ctor_get(x_1890, 1);
-x_2228 = lean_ctor_get(x_1890, 2);
-x_2229 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2229);
-lean_inc(x_2228);
-lean_inc(x_2227);
-lean_inc(x_2226);
-lean_dec(x_1890);
-x_2230 = lean_ctor_get(x_2096, 0);
-lean_inc(x_2230);
-x_2231 = lean_ctor_get(x_2096, 1);
-lean_inc(x_2231);
-x_2232 = lean_ctor_get(x_2096, 2);
-lean_inc(x_2232);
-x_2233 = lean_ctor_get(x_2096, 3);
-lean_inc(x_2233);
-if (lean_is_exclusive(x_2096)) {
- lean_ctor_release(x_2096, 0);
- lean_ctor_release(x_2096, 1);
- lean_ctor_release(x_2096, 2);
- lean_ctor_release(x_2096, 3);
- x_2234 = x_2096;
-} else {
- lean_dec_ref(x_2096);
- x_2234 = lean_box(0);
-}
-if (lean_is_scalar(x_2234)) {
- x_2235 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2235 = x_2234;
-}
-lean_ctor_set(x_2235, 0, x_2191);
-lean_ctor_set(x_2235, 1, x_2192);
-lean_ctor_set(x_2235, 2, x_2193);
-lean_ctor_set(x_2235, 3, x_2194);
-lean_ctor_set_uint8(x_2235, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-x_2236 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2236, 0, x_2235);
-lean_ctor_set(x_2236, 1, x_2185);
-lean_ctor_set(x_2236, 2, x_2186);
-lean_ctor_set(x_2236, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2237 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2237 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2236, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_4, 3, x_2229);
-lean_ctor_set(x_4, 2, x_2228);
-lean_ctor_set(x_4, 1, x_2227);
-lean_ctor_set(x_4, 0, x_2226);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2237)) {
- x_2238 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2238 = x_2237;
-}
-lean_ctor_set(x_2238, 0, x_2236);
-lean_ctor_set(x_2238, 1, x_2);
-lean_ctor_set(x_2238, 2, x_3);
-lean_ctor_set(x_2238, 3, x_4);
-lean_ctor_set_uint8(x_2238, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_2233);
-lean_ctor_set(x_234, 2, x_2232);
-lean_ctor_set(x_234, 1, x_2231);
-lean_ctor_set(x_234, 0, x_2230);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2196);
-lean_ctor_set(x_1, 1, x_2195);
-lean_ctor_set(x_1, 0, x_2238);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2239; lean_object* x_2240; lean_object* x_2241; lean_object* x_2242; lean_object* x_2243; lean_object* x_2244; lean_object* x_2245; lean_object* x_2246; lean_object* x_2247; lean_object* x_2248; lean_object* x_2249; lean_object* x_2250; lean_object* x_2251; lean_object* x_2252; lean_object* x_2253; lean_object* x_2254; lean_object* x_2255; lean_object* x_2256; lean_object* x_2257; lean_object* x_2258; lean_object* x_2259; 
-x_2239 = lean_ctor_get(x_234, 0);
-x_2240 = lean_ctor_get(x_234, 1);
-x_2241 = lean_ctor_get(x_234, 2);
-x_2242 = lean_ctor_get(x_234, 3);
-x_2243 = lean_ctor_get(x_4, 1);
-x_2244 = lean_ctor_get(x_4, 2);
-lean_inc(x_2244);
-lean_inc(x_2243);
-lean_dec(x_4);
-x_2245 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2245);
-x_2246 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2246);
-x_2247 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2247);
-x_2248 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2248);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2249 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2249 = lean_box(0);
-}
-x_2250 = lean_ctor_get(x_2096, 0);
-lean_inc(x_2250);
-x_2251 = lean_ctor_get(x_2096, 1);
-lean_inc(x_2251);
-x_2252 = lean_ctor_get(x_2096, 2);
-lean_inc(x_2252);
-x_2253 = lean_ctor_get(x_2096, 3);
-lean_inc(x_2253);
-if (lean_is_exclusive(x_2096)) {
- lean_ctor_release(x_2096, 0);
- lean_ctor_release(x_2096, 1);
- lean_ctor_release(x_2096, 2);
- lean_ctor_release(x_2096, 3);
- x_2254 = x_2096;
-} else {
- lean_dec_ref(x_2096);
- x_2254 = lean_box(0);
-}
-if (lean_is_scalar(x_2254)) {
- x_2255 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2255 = x_2254;
-}
-lean_ctor_set(x_2255, 0, x_2239);
-lean_ctor_set(x_2255, 1, x_2240);
-lean_ctor_set(x_2255, 2, x_2241);
-lean_ctor_set(x_2255, 3, x_2242);
-lean_ctor_set_uint8(x_2255, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-if (lean_is_scalar(x_2249)) {
- x_2256 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2256 = x_2249;
-}
-lean_ctor_set(x_2256, 0, x_2255);
-lean_ctor_set(x_2256, 1, x_2185);
-lean_ctor_set(x_2256, 2, x_2186);
-lean_ctor_set(x_2256, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2257 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2257 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2256, sizeof(void*)*4, x_2183);
-x_2258 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2258, 0, x_2245);
-lean_ctor_set(x_2258, 1, x_2246);
-lean_ctor_set(x_2258, 2, x_2247);
-lean_ctor_set(x_2258, 3, x_2248);
-lean_ctor_set_uint8(x_2258, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2257)) {
- x_2259 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2259 = x_2257;
-}
-lean_ctor_set(x_2259, 0, x_2256);
-lean_ctor_set(x_2259, 1, x_2);
-lean_ctor_set(x_2259, 2, x_3);
-lean_ctor_set(x_2259, 3, x_2258);
-lean_ctor_set_uint8(x_2259, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_234, 3, x_2253);
-lean_ctor_set(x_234, 2, x_2252);
-lean_ctor_set(x_234, 1, x_2251);
-lean_ctor_set(x_234, 0, x_2250);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 2, x_2244);
-lean_ctor_set(x_1, 1, x_2243);
-lean_ctor_set(x_1, 0, x_2259);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2260; lean_object* x_2261; lean_object* x_2262; lean_object* x_2263; lean_object* x_2264; lean_object* x_2265; lean_object* x_2266; lean_object* x_2267; lean_object* x_2268; lean_object* x_2269; lean_object* x_2270; lean_object* x_2271; lean_object* x_2272; lean_object* x_2273; lean_object* x_2274; lean_object* x_2275; lean_object* x_2276; lean_object* x_2277; lean_object* x_2278; lean_object* x_2279; lean_object* x_2280; lean_object* x_2281; lean_object* x_2282; 
-x_2260 = lean_ctor_get(x_234, 0);
-x_2261 = lean_ctor_get(x_234, 1);
-x_2262 = lean_ctor_get(x_234, 2);
-x_2263 = lean_ctor_get(x_234, 3);
-lean_inc(x_2263);
-lean_inc(x_2262);
-lean_inc(x_2261);
-lean_inc(x_2260);
-lean_dec(x_234);
-x_2264 = lean_ctor_get(x_4, 1);
-lean_inc(x_2264);
-x_2265 = lean_ctor_get(x_4, 2);
-lean_inc(x_2265);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2266 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2266 = lean_box(0);
-}
-x_2267 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2267);
-x_2268 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2268);
-x_2269 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2269);
-x_2270 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2270);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2271 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2271 = lean_box(0);
-}
-x_2272 = lean_ctor_get(x_2096, 0);
-lean_inc(x_2272);
-x_2273 = lean_ctor_get(x_2096, 1);
-lean_inc(x_2273);
-x_2274 = lean_ctor_get(x_2096, 2);
-lean_inc(x_2274);
-x_2275 = lean_ctor_get(x_2096, 3);
-lean_inc(x_2275);
-if (lean_is_exclusive(x_2096)) {
- lean_ctor_release(x_2096, 0);
- lean_ctor_release(x_2096, 1);
- lean_ctor_release(x_2096, 2);
- lean_ctor_release(x_2096, 3);
- x_2276 = x_2096;
-} else {
- lean_dec_ref(x_2096);
- x_2276 = lean_box(0);
-}
-if (lean_is_scalar(x_2276)) {
- x_2277 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2277 = x_2276;
-}
-lean_ctor_set(x_2277, 0, x_2260);
-lean_ctor_set(x_2277, 1, x_2261);
-lean_ctor_set(x_2277, 2, x_2262);
-lean_ctor_set(x_2277, 3, x_2263);
-lean_ctor_set_uint8(x_2277, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-if (lean_is_scalar(x_2271)) {
- x_2278 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2278 = x_2271;
-}
-lean_ctor_set(x_2278, 0, x_2277);
-lean_ctor_set(x_2278, 1, x_2185);
-lean_ctor_set(x_2278, 2, x_2186);
-lean_ctor_set(x_2278, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2279 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2279 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2278, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2266)) {
- x_2280 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2280 = x_2266;
-}
-lean_ctor_set(x_2280, 0, x_2267);
-lean_ctor_set(x_2280, 1, x_2268);
-lean_ctor_set(x_2280, 2, x_2269);
-lean_ctor_set(x_2280, 3, x_2270);
-lean_ctor_set_uint8(x_2280, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2279)) {
- x_2281 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2281 = x_2279;
-}
-lean_ctor_set(x_2281, 0, x_2278);
-lean_ctor_set(x_2281, 1, x_2);
-lean_ctor_set(x_2281, 2, x_3);
-lean_ctor_set(x_2281, 3, x_2280);
-lean_ctor_set_uint8(x_2281, sizeof(void*)*4, x_1833);
-x_2282 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2282, 0, x_2272);
-lean_ctor_set(x_2282, 1, x_2273);
-lean_ctor_set(x_2282, 2, x_2274);
-lean_ctor_set(x_2282, 3, x_2275);
-lean_ctor_set_uint8(x_2282, sizeof(void*)*4, x_1833);
-lean_ctor_set(x_1, 3, x_2282);
-lean_ctor_set(x_1, 2, x_2265);
-lean_ctor_set(x_1, 1, x_2264);
-lean_ctor_set(x_1, 0, x_2281);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2283; lean_object* x_2284; lean_object* x_2285; lean_object* x_2286; lean_object* x_2287; lean_object* x_2288; lean_object* x_2289; lean_object* x_2290; lean_object* x_2291; lean_object* x_2292; lean_object* x_2293; lean_object* x_2294; lean_object* x_2295; lean_object* x_2296; lean_object* x_2297; lean_object* x_2298; lean_object* x_2299; lean_object* x_2300; lean_object* x_2301; lean_object* x_2302; lean_object* x_2303; lean_object* x_2304; lean_object* x_2305; lean_object* x_2306; lean_object* x_2307; lean_object* x_2308; lean_object* x_2309; 
-x_2283 = lean_ctor_get(x_1, 1);
-x_2284 = lean_ctor_get(x_1, 2);
-lean_inc(x_2284);
-lean_inc(x_2283);
-lean_dec(x_1);
-x_2285 = lean_ctor_get(x_234, 0);
-lean_inc(x_2285);
-x_2286 = lean_ctor_get(x_234, 1);
-lean_inc(x_2286);
-x_2287 = lean_ctor_get(x_234, 2);
-lean_inc(x_2287);
-x_2288 = lean_ctor_get(x_234, 3);
-lean_inc(x_2288);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2289 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2289 = lean_box(0);
-}
-x_2290 = lean_ctor_get(x_4, 1);
-lean_inc(x_2290);
-x_2291 = lean_ctor_get(x_4, 2);
-lean_inc(x_2291);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2292 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2292 = lean_box(0);
-}
-x_2293 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2293);
-x_2294 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2294);
-x_2295 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2295);
-x_2296 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2296);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2297 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2297 = lean_box(0);
-}
-x_2298 = lean_ctor_get(x_2096, 0);
-lean_inc(x_2298);
-x_2299 = lean_ctor_get(x_2096, 1);
-lean_inc(x_2299);
-x_2300 = lean_ctor_get(x_2096, 2);
-lean_inc(x_2300);
-x_2301 = lean_ctor_get(x_2096, 3);
-lean_inc(x_2301);
-if (lean_is_exclusive(x_2096)) {
- lean_ctor_release(x_2096, 0);
- lean_ctor_release(x_2096, 1);
- lean_ctor_release(x_2096, 2);
- lean_ctor_release(x_2096, 3);
- x_2302 = x_2096;
-} else {
- lean_dec_ref(x_2096);
- x_2302 = lean_box(0);
-}
-if (lean_is_scalar(x_2302)) {
- x_2303 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2303 = x_2302;
-}
-lean_ctor_set(x_2303, 0, x_2285);
-lean_ctor_set(x_2303, 1, x_2286);
-lean_ctor_set(x_2303, 2, x_2287);
-lean_ctor_set(x_2303, 3, x_2288);
-lean_ctor_set_uint8(x_2303, sizeof(void*)*4, x_1833);
-lean_inc(x_1265);
-if (lean_is_scalar(x_2297)) {
- x_2304 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2304 = x_2297;
-}
-lean_ctor_set(x_2304, 0, x_2303);
-lean_ctor_set(x_2304, 1, x_2283);
-lean_ctor_set(x_2304, 2, x_2284);
-lean_ctor_set(x_2304, 3, x_1265);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2305 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2305 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2304, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2292)) {
- x_2306 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2306 = x_2292;
-}
-lean_ctor_set(x_2306, 0, x_2293);
-lean_ctor_set(x_2306, 1, x_2294);
-lean_ctor_set(x_2306, 2, x_2295);
-lean_ctor_set(x_2306, 3, x_2296);
-lean_ctor_set_uint8(x_2306, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2305)) {
- x_2307 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2307 = x_2305;
-}
-lean_ctor_set(x_2307, 0, x_2304);
-lean_ctor_set(x_2307, 1, x_2);
-lean_ctor_set(x_2307, 2, x_3);
-lean_ctor_set(x_2307, 3, x_2306);
-lean_ctor_set_uint8(x_2307, sizeof(void*)*4, x_1833);
-if (lean_is_scalar(x_2289)) {
- x_2308 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2308 = x_2289;
-}
-lean_ctor_set(x_2308, 0, x_2298);
-lean_ctor_set(x_2308, 1, x_2299);
-lean_ctor_set(x_2308, 2, x_2300);
-lean_ctor_set(x_2308, 3, x_2301);
-lean_ctor_set_uint8(x_2308, sizeof(void*)*4, x_1833);
-x_2309 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2309, 0, x_2307);
-lean_ctor_set(x_2309, 1, x_2290);
-lean_ctor_set(x_2309, 2, x_2291);
-lean_ctor_set(x_2309, 3, x_2308);
-lean_ctor_set_uint8(x_2309, sizeof(void*)*4, x_2183);
-return x_2309;
-}
-}
-else
-{
-uint8_t x_2310; 
-x_2310 = !lean_is_exclusive(x_1);
-if (x_2310 == 0)
-{
-lean_object* x_2311; lean_object* x_2312; lean_object* x_2313; lean_object* x_2314; uint8_t x_2315; 
-x_2311 = lean_ctor_get(x_1, 1);
-x_2312 = lean_ctor_get(x_1, 2);
-x_2313 = lean_ctor_get(x_1, 3);
-lean_dec(x_2313);
-x_2314 = lean_ctor_get(x_1, 0);
-lean_dec(x_2314);
-x_2315 = !lean_is_exclusive(x_234);
-if (x_2315 == 0)
-{
-uint8_t x_2316; 
-x_2316 = !lean_is_exclusive(x_1265);
-if (x_2316 == 0)
-{
-uint8_t x_2317; 
-x_2317 = !lean_is_exclusive(x_4);
-if (x_2317 == 0)
-{
-lean_object* x_2318; lean_object* x_2319; lean_object* x_2320; lean_object* x_2321; lean_object* x_2322; lean_object* x_2323; lean_object* x_2324; lean_object* x_2325; lean_object* x_2326; lean_object* x_2327; lean_object* x_2328; lean_object* x_2329; uint8_t x_2330; 
-x_2318 = lean_ctor_get(x_234, 0);
-x_2319 = lean_ctor_get(x_234, 1);
-x_2320 = lean_ctor_get(x_234, 2);
-x_2321 = lean_ctor_get(x_234, 3);
-x_2322 = lean_ctor_get(x_1265, 0);
-x_2323 = lean_ctor_get(x_1265, 1);
-x_2324 = lean_ctor_get(x_1265, 2);
-x_2325 = lean_ctor_get(x_1265, 3);
-x_2326 = lean_ctor_get(x_4, 1);
-x_2327 = lean_ctor_get(x_4, 2);
-x_2328 = lean_ctor_get(x_4, 3);
-lean_dec(x_2328);
-x_2329 = lean_ctor_get(x_4, 0);
-lean_dec(x_2329);
-x_2330 = !lean_is_exclusive(x_1890);
-if (x_2330 == 0)
-{
-lean_object* x_2331; lean_object* x_2332; lean_object* x_2333; lean_object* x_2334; lean_object* x_2335; 
-x_2331 = lean_ctor_get(x_1890, 0);
-x_2332 = lean_ctor_get(x_1890, 1);
-x_2333 = lean_ctor_get(x_1890, 2);
-x_2334 = lean_ctor_get(x_1890, 3);
-lean_ctor_set(x_1890, 3, x_2321);
-lean_ctor_set(x_1890, 2, x_2320);
-lean_ctor_set(x_1890, 1, x_2319);
-lean_ctor_set(x_1890, 0, x_2318);
-lean_ctor_set_uint8(x_1890, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_4, 3, x_2325);
-lean_ctor_set(x_4, 2, x_2324);
-lean_ctor_set(x_4, 1, x_2323);
-lean_ctor_set(x_4, 0, x_2322);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1265, 3, x_4);
-lean_ctor_set(x_1265, 2, x_2312);
-lean_ctor_set(x_1265, 1, x_2311);
-lean_ctor_set(x_1265, 0, x_1890);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_234, 3, x_2331);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1265);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1, 3, x_2096);
-lean_ctor_set(x_1, 2, x_2327);
-lean_ctor_set(x_1, 1, x_2326);
-lean_ctor_set(x_1, 0, x_2334);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-x_2335 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2335, 0, x_234);
-lean_ctor_set(x_2335, 1, x_2332);
-lean_ctor_set(x_2335, 2, x_2333);
-lean_ctor_set(x_2335, 3, x_1);
-lean_ctor_set_uint8(x_2335, sizeof(void*)*4, x_2095);
-return x_2335;
-}
-else
-{
-lean_object* x_2336; lean_object* x_2337; lean_object* x_2338; lean_object* x_2339; lean_object* x_2340; lean_object* x_2341; 
-x_2336 = lean_ctor_get(x_1890, 0);
-x_2337 = lean_ctor_get(x_1890, 1);
-x_2338 = lean_ctor_get(x_1890, 2);
-x_2339 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2339);
-lean_inc(x_2338);
-lean_inc(x_2337);
-lean_inc(x_2336);
-lean_dec(x_1890);
-x_2340 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2340, 0, x_2318);
-lean_ctor_set(x_2340, 1, x_2319);
-lean_ctor_set(x_2340, 2, x_2320);
-lean_ctor_set(x_2340, 3, x_2321);
-lean_ctor_set_uint8(x_2340, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_4, 3, x_2325);
-lean_ctor_set(x_4, 2, x_2324);
-lean_ctor_set(x_4, 1, x_2323);
-lean_ctor_set(x_4, 0, x_2322);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1265, 3, x_4);
-lean_ctor_set(x_1265, 2, x_2312);
-lean_ctor_set(x_1265, 1, x_2311);
-lean_ctor_set(x_1265, 0, x_2340);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_234, 3, x_2336);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1265);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1, 3, x_2096);
-lean_ctor_set(x_1, 2, x_2327);
-lean_ctor_set(x_1, 1, x_2326);
-lean_ctor_set(x_1, 0, x_2339);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-x_2341 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2341, 0, x_234);
-lean_ctor_set(x_2341, 1, x_2337);
-lean_ctor_set(x_2341, 2, x_2338);
-lean_ctor_set(x_2341, 3, x_1);
-lean_ctor_set_uint8(x_2341, sizeof(void*)*4, x_2095);
-return x_2341;
-}
-}
-else
-{
-lean_object* x_2342; lean_object* x_2343; lean_object* x_2344; lean_object* x_2345; lean_object* x_2346; lean_object* x_2347; lean_object* x_2348; lean_object* x_2349; lean_object* x_2350; lean_object* x_2351; lean_object* x_2352; lean_object* x_2353; lean_object* x_2354; lean_object* x_2355; lean_object* x_2356; lean_object* x_2357; lean_object* x_2358; lean_object* x_2359; 
-x_2342 = lean_ctor_get(x_234, 0);
-x_2343 = lean_ctor_get(x_234, 1);
-x_2344 = lean_ctor_get(x_234, 2);
-x_2345 = lean_ctor_get(x_234, 3);
-x_2346 = lean_ctor_get(x_1265, 0);
-x_2347 = lean_ctor_get(x_1265, 1);
-x_2348 = lean_ctor_get(x_1265, 2);
-x_2349 = lean_ctor_get(x_1265, 3);
-x_2350 = lean_ctor_get(x_4, 1);
-x_2351 = lean_ctor_get(x_4, 2);
-lean_inc(x_2351);
-lean_inc(x_2350);
-lean_dec(x_4);
-x_2352 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2352);
-x_2353 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2353);
-x_2354 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2354);
-x_2355 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2355);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2356 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2356 = lean_box(0);
-}
-if (lean_is_scalar(x_2356)) {
- x_2357 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2357 = x_2356;
-}
-lean_ctor_set(x_2357, 0, x_2342);
-lean_ctor_set(x_2357, 1, x_2343);
-lean_ctor_set(x_2357, 2, x_2344);
-lean_ctor_set(x_2357, 3, x_2345);
-lean_ctor_set_uint8(x_2357, sizeof(void*)*4, x_2183);
-x_2358 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2358, 0, x_2346);
-lean_ctor_set(x_2358, 1, x_2347);
-lean_ctor_set(x_2358, 2, x_2348);
-lean_ctor_set(x_2358, 3, x_2349);
-lean_ctor_set_uint8(x_2358, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1265, 3, x_2358);
-lean_ctor_set(x_1265, 2, x_2312);
-lean_ctor_set(x_1265, 1, x_2311);
-lean_ctor_set(x_1265, 0, x_2357);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_234, 3, x_2352);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1265);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1, 3, x_2096);
-lean_ctor_set(x_1, 2, x_2351);
-lean_ctor_set(x_1, 1, x_2350);
-lean_ctor_set(x_1, 0, x_2355);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-x_2359 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2359, 0, x_234);
-lean_ctor_set(x_2359, 1, x_2353);
-lean_ctor_set(x_2359, 2, x_2354);
-lean_ctor_set(x_2359, 3, x_1);
-lean_ctor_set_uint8(x_2359, sizeof(void*)*4, x_2095);
-return x_2359;
-}
-}
-else
-{
-lean_object* x_2360; lean_object* x_2361; lean_object* x_2362; lean_object* x_2363; lean_object* x_2364; lean_object* x_2365; lean_object* x_2366; lean_object* x_2367; lean_object* x_2368; lean_object* x_2369; lean_object* x_2370; lean_object* x_2371; lean_object* x_2372; lean_object* x_2373; lean_object* x_2374; lean_object* x_2375; lean_object* x_2376; lean_object* x_2377; lean_object* x_2378; lean_object* x_2379; 
-x_2360 = lean_ctor_get(x_234, 0);
-x_2361 = lean_ctor_get(x_234, 1);
-x_2362 = lean_ctor_get(x_234, 2);
-x_2363 = lean_ctor_get(x_234, 3);
-x_2364 = lean_ctor_get(x_1265, 0);
-x_2365 = lean_ctor_get(x_1265, 1);
-x_2366 = lean_ctor_get(x_1265, 2);
-x_2367 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2367);
-lean_inc(x_2366);
-lean_inc(x_2365);
-lean_inc(x_2364);
-lean_dec(x_1265);
-x_2368 = lean_ctor_get(x_4, 1);
-lean_inc(x_2368);
-x_2369 = lean_ctor_get(x_4, 2);
-lean_inc(x_2369);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2370 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2370 = lean_box(0);
-}
-x_2371 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2371);
-x_2372 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2372);
-x_2373 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2373);
-x_2374 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2374);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2375 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2375 = lean_box(0);
-}
-if (lean_is_scalar(x_2375)) {
- x_2376 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2376 = x_2375;
-}
-lean_ctor_set(x_2376, 0, x_2360);
-lean_ctor_set(x_2376, 1, x_2361);
-lean_ctor_set(x_2376, 2, x_2362);
-lean_ctor_set(x_2376, 3, x_2363);
-lean_ctor_set_uint8(x_2376, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2370)) {
- x_2377 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2377 = x_2370;
-}
-lean_ctor_set(x_2377, 0, x_2364);
-lean_ctor_set(x_2377, 1, x_2365);
-lean_ctor_set(x_2377, 2, x_2366);
-lean_ctor_set(x_2377, 3, x_2367);
-lean_ctor_set_uint8(x_2377, sizeof(void*)*4, x_2183);
-x_2378 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2378, 0, x_2376);
-lean_ctor_set(x_2378, 1, x_2311);
-lean_ctor_set(x_2378, 2, x_2312);
-lean_ctor_set(x_2378, 3, x_2377);
-lean_ctor_set_uint8(x_2378, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_234, 3, x_2371);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_2378);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1, 3, x_2096);
-lean_ctor_set(x_1, 2, x_2369);
-lean_ctor_set(x_1, 1, x_2368);
-lean_ctor_set(x_1, 0, x_2374);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-x_2379 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2379, 0, x_234);
-lean_ctor_set(x_2379, 1, x_2372);
-lean_ctor_set(x_2379, 2, x_2373);
-lean_ctor_set(x_2379, 3, x_1);
-lean_ctor_set_uint8(x_2379, sizeof(void*)*4, x_2095);
-return x_2379;
-}
-}
-else
-{
-lean_object* x_2380; lean_object* x_2381; lean_object* x_2382; lean_object* x_2383; lean_object* x_2384; lean_object* x_2385; lean_object* x_2386; lean_object* x_2387; lean_object* x_2388; lean_object* x_2389; lean_object* x_2390; lean_object* x_2391; lean_object* x_2392; lean_object* x_2393; lean_object* x_2394; lean_object* x_2395; lean_object* x_2396; lean_object* x_2397; lean_object* x_2398; lean_object* x_2399; lean_object* x_2400; lean_object* x_2401; 
-x_2380 = lean_ctor_get(x_234, 0);
-x_2381 = lean_ctor_get(x_234, 1);
-x_2382 = lean_ctor_get(x_234, 2);
-x_2383 = lean_ctor_get(x_234, 3);
-lean_inc(x_2383);
-lean_inc(x_2382);
-lean_inc(x_2381);
-lean_inc(x_2380);
-lean_dec(x_234);
-x_2384 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2384);
-x_2385 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2385);
-x_2386 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2386);
-x_2387 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2387);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2388 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2388 = lean_box(0);
-}
-x_2389 = lean_ctor_get(x_4, 1);
-lean_inc(x_2389);
-x_2390 = lean_ctor_get(x_4, 2);
-lean_inc(x_2390);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2391 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2391 = lean_box(0);
-}
-x_2392 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2392);
-x_2393 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2393);
-x_2394 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2394);
-x_2395 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2395);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2396 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2396 = lean_box(0);
-}
-if (lean_is_scalar(x_2396)) {
- x_2397 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2397 = x_2396;
-}
-lean_ctor_set(x_2397, 0, x_2380);
-lean_ctor_set(x_2397, 1, x_2381);
-lean_ctor_set(x_2397, 2, x_2382);
-lean_ctor_set(x_2397, 3, x_2383);
-lean_ctor_set_uint8(x_2397, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2391)) {
- x_2398 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2398 = x_2391;
-}
-lean_ctor_set(x_2398, 0, x_2384);
-lean_ctor_set(x_2398, 1, x_2385);
-lean_ctor_set(x_2398, 2, x_2386);
-lean_ctor_set(x_2398, 3, x_2387);
-lean_ctor_set_uint8(x_2398, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2388)) {
- x_2399 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2399 = x_2388;
-}
-lean_ctor_set(x_2399, 0, x_2397);
-lean_ctor_set(x_2399, 1, x_2311);
-lean_ctor_set(x_2399, 2, x_2312);
-lean_ctor_set(x_2399, 3, x_2398);
-lean_ctor_set_uint8(x_2399, sizeof(void*)*4, x_2095);
-x_2400 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2400, 0, x_2399);
-lean_ctor_set(x_2400, 1, x_2);
-lean_ctor_set(x_2400, 2, x_3);
-lean_ctor_set(x_2400, 3, x_2392);
-lean_ctor_set_uint8(x_2400, sizeof(void*)*4, x_2183);
-lean_ctor_set(x_1, 3, x_2096);
-lean_ctor_set(x_1, 2, x_2390);
-lean_ctor_set(x_1, 1, x_2389);
-lean_ctor_set(x_1, 0, x_2395);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2183);
-x_2401 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2401, 0, x_2400);
-lean_ctor_set(x_2401, 1, x_2393);
-lean_ctor_set(x_2401, 2, x_2394);
-lean_ctor_set(x_2401, 3, x_1);
-lean_ctor_set_uint8(x_2401, sizeof(void*)*4, x_2095);
-return x_2401;
-}
-}
-else
-{
-lean_object* x_2402; lean_object* x_2403; lean_object* x_2404; lean_object* x_2405; lean_object* x_2406; lean_object* x_2407; lean_object* x_2408; lean_object* x_2409; lean_object* x_2410; lean_object* x_2411; lean_object* x_2412; lean_object* x_2413; lean_object* x_2414; lean_object* x_2415; lean_object* x_2416; lean_object* x_2417; lean_object* x_2418; lean_object* x_2419; lean_object* x_2420; lean_object* x_2421; lean_object* x_2422; lean_object* x_2423; lean_object* x_2424; lean_object* x_2425; lean_object* x_2426; lean_object* x_2427; 
-x_2402 = lean_ctor_get(x_1, 1);
-x_2403 = lean_ctor_get(x_1, 2);
-lean_inc(x_2403);
-lean_inc(x_2402);
-lean_dec(x_1);
-x_2404 = lean_ctor_get(x_234, 0);
-lean_inc(x_2404);
-x_2405 = lean_ctor_get(x_234, 1);
-lean_inc(x_2405);
-x_2406 = lean_ctor_get(x_234, 2);
-lean_inc(x_2406);
-x_2407 = lean_ctor_get(x_234, 3);
-lean_inc(x_2407);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2408 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2408 = lean_box(0);
-}
-x_2409 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2409);
-x_2410 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2410);
-x_2411 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2411);
-x_2412 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2412);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2413 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2413 = lean_box(0);
-}
-x_2414 = lean_ctor_get(x_4, 1);
-lean_inc(x_2414);
-x_2415 = lean_ctor_get(x_4, 2);
-lean_inc(x_2415);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2416 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2416 = lean_box(0);
-}
-x_2417 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2417);
-x_2418 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2418);
-x_2419 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2419);
-x_2420 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2420);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2421 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2421 = lean_box(0);
-}
-if (lean_is_scalar(x_2421)) {
- x_2422 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2422 = x_2421;
-}
-lean_ctor_set(x_2422, 0, x_2404);
-lean_ctor_set(x_2422, 1, x_2405);
-lean_ctor_set(x_2422, 2, x_2406);
-lean_ctor_set(x_2422, 3, x_2407);
-lean_ctor_set_uint8(x_2422, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2416)) {
- x_2423 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2423 = x_2416;
-}
-lean_ctor_set(x_2423, 0, x_2409);
-lean_ctor_set(x_2423, 1, x_2410);
-lean_ctor_set(x_2423, 2, x_2411);
-lean_ctor_set(x_2423, 3, x_2412);
-lean_ctor_set_uint8(x_2423, sizeof(void*)*4, x_2183);
-if (lean_is_scalar(x_2413)) {
- x_2424 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2424 = x_2413;
-}
-lean_ctor_set(x_2424, 0, x_2422);
-lean_ctor_set(x_2424, 1, x_2402);
-lean_ctor_set(x_2424, 2, x_2403);
-lean_ctor_set(x_2424, 3, x_2423);
-lean_ctor_set_uint8(x_2424, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2408)) {
- x_2425 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2425 = x_2408;
-}
-lean_ctor_set(x_2425, 0, x_2424);
-lean_ctor_set(x_2425, 1, x_2);
-lean_ctor_set(x_2425, 2, x_3);
-lean_ctor_set(x_2425, 3, x_2417);
-lean_ctor_set_uint8(x_2425, sizeof(void*)*4, x_2183);
-x_2426 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2426, 0, x_2420);
-lean_ctor_set(x_2426, 1, x_2414);
-lean_ctor_set(x_2426, 2, x_2415);
-lean_ctor_set(x_2426, 3, x_2096);
-lean_ctor_set_uint8(x_2426, sizeof(void*)*4, x_2183);
-x_2427 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2427, 0, x_2425);
-lean_ctor_set(x_2427, 1, x_2418);
-lean_ctor_set(x_2427, 2, x_2419);
-lean_ctor_set(x_2427, 3, x_2426);
-lean_ctor_set_uint8(x_2427, sizeof(void*)*4, x_2095);
-return x_2427;
-}
-}
-}
-}
-else
-{
-lean_object* x_2428; 
-x_2428 = lean_ctor_get(x_4, 3);
-lean_inc(x_2428);
-if (lean_obj_tag(x_2428) == 0)
-{
-uint8_t x_2429; 
-x_2429 = !lean_is_exclusive(x_1890);
-if (x_2429 == 0)
-{
-lean_object* x_2430; lean_object* x_2431; lean_object* x_2432; lean_object* x_2433; uint8_t x_2434; 
-x_2430 = lean_ctor_get(x_1890, 3);
-lean_dec(x_2430);
-x_2431 = lean_ctor_get(x_1890, 2);
-lean_dec(x_2431);
-x_2432 = lean_ctor_get(x_1890, 1);
-lean_dec(x_2432);
-x_2433 = lean_ctor_get(x_1890, 0);
-lean_dec(x_2433);
-x_2434 = !lean_is_exclusive(x_1);
-if (x_2434 == 0)
-{
-lean_object* x_2435; lean_object* x_2436; lean_object* x_2437; lean_object* x_2438; uint8_t x_2439; 
-x_2435 = lean_ctor_get(x_1, 1);
-x_2436 = lean_ctor_get(x_1, 2);
-x_2437 = lean_ctor_get(x_1, 3);
-lean_dec(x_2437);
-x_2438 = lean_ctor_get(x_1, 0);
-lean_dec(x_2438);
-x_2439 = !lean_is_exclusive(x_234);
-if (x_2439 == 0)
-{
-uint8_t x_2440; 
-x_2440 = !lean_is_exclusive(x_1265);
-if (x_2440 == 0)
-{
-lean_object* x_2441; lean_object* x_2442; lean_object* x_2443; lean_object* x_2444; 
-x_2441 = lean_ctor_get(x_234, 0);
-x_2442 = lean_ctor_get(x_234, 1);
-x_2443 = lean_ctor_get(x_234, 2);
-x_2444 = lean_ctor_get(x_234, 3);
-lean_ctor_set(x_1890, 3, x_2444);
-lean_ctor_set(x_1890, 2, x_2443);
-lean_ctor_set(x_1890, 1, x_2442);
-lean_ctor_set(x_1890, 0, x_2441);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_234, 3, x_1265);
-lean_ctor_set(x_234, 2, x_2436);
-lean_ctor_set(x_234, 1, x_2435);
-lean_ctor_set(x_234, 0, x_1890);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-else
-{
-lean_object* x_2445; lean_object* x_2446; lean_object* x_2447; lean_object* x_2448; lean_object* x_2449; lean_object* x_2450; lean_object* x_2451; lean_object* x_2452; lean_object* x_2453; 
-x_2445 = lean_ctor_get(x_234, 0);
-x_2446 = lean_ctor_get(x_234, 1);
-x_2447 = lean_ctor_get(x_234, 2);
-x_2448 = lean_ctor_get(x_234, 3);
-x_2449 = lean_ctor_get(x_1265, 0);
-x_2450 = lean_ctor_get(x_1265, 1);
-x_2451 = lean_ctor_get(x_1265, 2);
-x_2452 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2452);
-lean_inc(x_2451);
-lean_inc(x_2450);
-lean_inc(x_2449);
-lean_dec(x_1265);
-lean_ctor_set(x_1890, 3, x_2448);
-lean_ctor_set(x_1890, 2, x_2447);
-lean_ctor_set(x_1890, 1, x_2446);
-lean_ctor_set(x_1890, 0, x_2445);
-x_2453 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2453, 0, x_2449);
-lean_ctor_set(x_2453, 1, x_2450);
-lean_ctor_set(x_2453, 2, x_2451);
-lean_ctor_set(x_2453, 3, x_2452);
-lean_ctor_set_uint8(x_2453, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_234, 3, x_2453);
-lean_ctor_set(x_234, 2, x_2436);
-lean_ctor_set(x_234, 1, x_2435);
-lean_ctor_set(x_234, 0, x_1890);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2454; lean_object* x_2455; lean_object* x_2456; lean_object* x_2457; lean_object* x_2458; lean_object* x_2459; lean_object* x_2460; lean_object* x_2461; lean_object* x_2462; lean_object* x_2463; lean_object* x_2464; 
-x_2454 = lean_ctor_get(x_234, 0);
-x_2455 = lean_ctor_get(x_234, 1);
-x_2456 = lean_ctor_get(x_234, 2);
-x_2457 = lean_ctor_get(x_234, 3);
-lean_inc(x_2457);
-lean_inc(x_2456);
-lean_inc(x_2455);
-lean_inc(x_2454);
-lean_dec(x_234);
-x_2458 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2458);
-x_2459 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2459);
-x_2460 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2460);
-x_2461 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2461);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2462 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2462 = lean_box(0);
-}
-lean_ctor_set(x_1890, 3, x_2457);
-lean_ctor_set(x_1890, 2, x_2456);
-lean_ctor_set(x_1890, 1, x_2455);
-lean_ctor_set(x_1890, 0, x_2454);
-if (lean_is_scalar(x_2462)) {
- x_2463 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2463 = x_2462;
-}
-lean_ctor_set(x_2463, 0, x_2458);
-lean_ctor_set(x_2463, 1, x_2459);
-lean_ctor_set(x_2463, 2, x_2460);
-lean_ctor_set(x_2463, 3, x_2461);
-lean_ctor_set_uint8(x_2463, sizeof(void*)*4, x_2095);
-x_2464 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2464, 0, x_1890);
-lean_ctor_set(x_2464, 1, x_2435);
-lean_ctor_set(x_2464, 2, x_2436);
-lean_ctor_set(x_2464, 3, x_2463);
-lean_ctor_set_uint8(x_2464, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_2464);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-return x_1;
-}
-}
-else
-{
-lean_object* x_2465; lean_object* x_2466; lean_object* x_2467; lean_object* x_2468; lean_object* x_2469; lean_object* x_2470; lean_object* x_2471; lean_object* x_2472; lean_object* x_2473; lean_object* x_2474; lean_object* x_2475; lean_object* x_2476; lean_object* x_2477; lean_object* x_2478; lean_object* x_2479; 
-x_2465 = lean_ctor_get(x_1, 1);
-x_2466 = lean_ctor_get(x_1, 2);
-lean_inc(x_2466);
-lean_inc(x_2465);
-lean_dec(x_1);
-x_2467 = lean_ctor_get(x_234, 0);
-lean_inc(x_2467);
-x_2468 = lean_ctor_get(x_234, 1);
-lean_inc(x_2468);
-x_2469 = lean_ctor_get(x_234, 2);
-lean_inc(x_2469);
-x_2470 = lean_ctor_get(x_234, 3);
-lean_inc(x_2470);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2471 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2471 = lean_box(0);
-}
-x_2472 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2472);
-x_2473 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2473);
-x_2474 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2474);
-x_2475 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2475);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2476 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2476 = lean_box(0);
-}
-lean_ctor_set(x_1890, 3, x_2470);
-lean_ctor_set(x_1890, 2, x_2469);
-lean_ctor_set(x_1890, 1, x_2468);
-lean_ctor_set(x_1890, 0, x_2467);
-if (lean_is_scalar(x_2476)) {
- x_2477 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2477 = x_2476;
-}
-lean_ctor_set(x_2477, 0, x_2472);
-lean_ctor_set(x_2477, 1, x_2473);
-lean_ctor_set(x_2477, 2, x_2474);
-lean_ctor_set(x_2477, 3, x_2475);
-lean_ctor_set_uint8(x_2477, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2471)) {
- x_2478 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2478 = x_2471;
-}
-lean_ctor_set(x_2478, 0, x_1890);
-lean_ctor_set(x_2478, 1, x_2465);
-lean_ctor_set(x_2478, 2, x_2466);
-lean_ctor_set(x_2478, 3, x_2477);
-lean_ctor_set_uint8(x_2478, sizeof(void*)*4, x_1889);
-x_2479 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2479, 0, x_2478);
-lean_ctor_set(x_2479, 1, x_2);
-lean_ctor_set(x_2479, 2, x_3);
-lean_ctor_set(x_2479, 3, x_4);
-lean_ctor_set_uint8(x_2479, sizeof(void*)*4, x_2095);
-return x_2479;
-}
-}
-else
-{
-lean_object* x_2480; lean_object* x_2481; lean_object* x_2482; lean_object* x_2483; lean_object* x_2484; lean_object* x_2485; lean_object* x_2486; lean_object* x_2487; lean_object* x_2488; lean_object* x_2489; lean_object* x_2490; lean_object* x_2491; lean_object* x_2492; lean_object* x_2493; lean_object* x_2494; lean_object* x_2495; lean_object* x_2496; 
-lean_dec(x_1890);
-x_2480 = lean_ctor_get(x_1, 1);
-lean_inc(x_2480);
-x_2481 = lean_ctor_get(x_1, 2);
-lean_inc(x_2481);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2482 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2482 = lean_box(0);
-}
-x_2483 = lean_ctor_get(x_234, 0);
-lean_inc(x_2483);
-x_2484 = lean_ctor_get(x_234, 1);
-lean_inc(x_2484);
-x_2485 = lean_ctor_get(x_234, 2);
-lean_inc(x_2485);
-x_2486 = lean_ctor_get(x_234, 3);
-lean_inc(x_2486);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2487 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2487 = lean_box(0);
-}
-x_2488 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2488);
-x_2489 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2489);
-x_2490 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2490);
-x_2491 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2491);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2492 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2492 = lean_box(0);
-}
-x_2493 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2493, 0, x_2483);
-lean_ctor_set(x_2493, 1, x_2484);
-lean_ctor_set(x_2493, 2, x_2485);
-lean_ctor_set(x_2493, 3, x_2486);
-lean_ctor_set_uint8(x_2493, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2492)) {
- x_2494 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2494 = x_2492;
-}
-lean_ctor_set(x_2494, 0, x_2488);
-lean_ctor_set(x_2494, 1, x_2489);
-lean_ctor_set(x_2494, 2, x_2490);
-lean_ctor_set(x_2494, 3, x_2491);
-lean_ctor_set_uint8(x_2494, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2487)) {
- x_2495 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2495 = x_2487;
-}
-lean_ctor_set(x_2495, 0, x_2493);
-lean_ctor_set(x_2495, 1, x_2480);
-lean_ctor_set(x_2495, 2, x_2481);
-lean_ctor_set(x_2495, 3, x_2494);
-lean_ctor_set_uint8(x_2495, sizeof(void*)*4, x_1889);
-if (lean_is_scalar(x_2482)) {
- x_2496 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2496 = x_2482;
-}
-lean_ctor_set(x_2496, 0, x_2495);
-lean_ctor_set(x_2496, 1, x_2);
-lean_ctor_set(x_2496, 2, x_3);
-lean_ctor_set(x_2496, 3, x_4);
-lean_ctor_set_uint8(x_2496, sizeof(void*)*4, x_2095);
-return x_2496;
-}
-}
-else
-{
-uint8_t x_2497; 
-x_2497 = lean_ctor_get_uint8(x_2428, sizeof(void*)*4);
-if (x_2497 == 0)
-{
-uint8_t x_2498; 
-x_2498 = !lean_is_exclusive(x_1);
-if (x_2498 == 0)
-{
-lean_object* x_2499; lean_object* x_2500; lean_object* x_2501; lean_object* x_2502; uint8_t x_2503; 
-x_2499 = lean_ctor_get(x_1, 1);
-x_2500 = lean_ctor_get(x_1, 2);
-x_2501 = lean_ctor_get(x_1, 3);
-lean_dec(x_2501);
-x_2502 = lean_ctor_get(x_1, 0);
-lean_dec(x_2502);
-x_2503 = !lean_is_exclusive(x_234);
-if (x_2503 == 0)
-{
-uint8_t x_2504; 
-x_2504 = !lean_is_exclusive(x_1265);
-if (x_2504 == 0)
-{
-uint8_t x_2505; 
-x_2505 = !lean_is_exclusive(x_4);
-if (x_2505 == 0)
-{
-lean_object* x_2506; lean_object* x_2507; lean_object* x_2508; lean_object* x_2509; lean_object* x_2510; lean_object* x_2511; lean_object* x_2512; lean_object* x_2513; lean_object* x_2514; lean_object* x_2515; lean_object* x_2516; lean_object* x_2517; uint8_t x_2518; 
-x_2506 = lean_ctor_get(x_234, 0);
-x_2507 = lean_ctor_get(x_234, 1);
-x_2508 = lean_ctor_get(x_234, 2);
-x_2509 = lean_ctor_get(x_234, 3);
-x_2510 = lean_ctor_get(x_1265, 0);
-x_2511 = lean_ctor_get(x_1265, 1);
-x_2512 = lean_ctor_get(x_1265, 2);
-x_2513 = lean_ctor_get(x_1265, 3);
-x_2514 = lean_ctor_get(x_4, 1);
-x_2515 = lean_ctor_get(x_4, 2);
-x_2516 = lean_ctor_get(x_4, 3);
-lean_dec(x_2516);
-x_2517 = lean_ctor_get(x_4, 0);
-lean_dec(x_2517);
-x_2518 = !lean_is_exclusive(x_2428);
-if (x_2518 == 0)
-{
-lean_object* x_2519; lean_object* x_2520; lean_object* x_2521; lean_object* x_2522; lean_object* x_2523; 
-x_2519 = lean_ctor_get(x_2428, 0);
-x_2520 = lean_ctor_get(x_2428, 1);
-x_2521 = lean_ctor_get(x_2428, 2);
-x_2522 = lean_ctor_get(x_2428, 3);
-lean_ctor_set(x_2428, 3, x_2509);
-lean_ctor_set(x_2428, 2, x_2508);
-lean_ctor_set(x_2428, 1, x_2507);
-lean_ctor_set(x_2428, 0, x_2506);
-lean_ctor_set_uint8(x_2428, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_4, 3, x_2513);
-lean_ctor_set(x_4, 2, x_2512);
-lean_ctor_set(x_4, 1, x_2511);
-lean_ctor_set(x_4, 0, x_2510);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1265, 3, x_4);
-lean_ctor_set(x_1265, 2, x_2500);
-lean_ctor_set(x_1265, 1, x_2499);
-lean_ctor_set(x_1265, 0, x_2428);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_234, 3, x_1890);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1265);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1, 3, x_2522);
-lean_ctor_set(x_1, 2, x_2521);
-lean_ctor_set(x_1, 1, x_2520);
-lean_ctor_set(x_1, 0, x_2519);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-x_2523 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2523, 0, x_234);
-lean_ctor_set(x_2523, 1, x_2514);
-lean_ctor_set(x_2523, 2, x_2515);
-lean_ctor_set(x_2523, 3, x_1);
-lean_ctor_set_uint8(x_2523, sizeof(void*)*4, x_2497);
-return x_2523;
-}
-else
-{
-lean_object* x_2524; lean_object* x_2525; lean_object* x_2526; lean_object* x_2527; lean_object* x_2528; lean_object* x_2529; 
-x_2524 = lean_ctor_get(x_2428, 0);
-x_2525 = lean_ctor_get(x_2428, 1);
-x_2526 = lean_ctor_get(x_2428, 2);
-x_2527 = lean_ctor_get(x_2428, 3);
-lean_inc(x_2527);
-lean_inc(x_2526);
-lean_inc(x_2525);
-lean_inc(x_2524);
-lean_dec(x_2428);
-x_2528 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2528, 0, x_2506);
-lean_ctor_set(x_2528, 1, x_2507);
-lean_ctor_set(x_2528, 2, x_2508);
-lean_ctor_set(x_2528, 3, x_2509);
-lean_ctor_set_uint8(x_2528, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_4, 3, x_2513);
-lean_ctor_set(x_4, 2, x_2512);
-lean_ctor_set(x_4, 1, x_2511);
-lean_ctor_set(x_4, 0, x_2510);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1265, 3, x_4);
-lean_ctor_set(x_1265, 2, x_2500);
-lean_ctor_set(x_1265, 1, x_2499);
-lean_ctor_set(x_1265, 0, x_2528);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_234, 3, x_1890);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1265);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1, 3, x_2527);
-lean_ctor_set(x_1, 2, x_2526);
-lean_ctor_set(x_1, 1, x_2525);
-lean_ctor_set(x_1, 0, x_2524);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-x_2529 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2529, 0, x_234);
-lean_ctor_set(x_2529, 1, x_2514);
-lean_ctor_set(x_2529, 2, x_2515);
-lean_ctor_set(x_2529, 3, x_1);
-lean_ctor_set_uint8(x_2529, sizeof(void*)*4, x_2497);
-return x_2529;
-}
-}
-else
-{
-lean_object* x_2530; lean_object* x_2531; lean_object* x_2532; lean_object* x_2533; lean_object* x_2534; lean_object* x_2535; lean_object* x_2536; lean_object* x_2537; lean_object* x_2538; lean_object* x_2539; lean_object* x_2540; lean_object* x_2541; lean_object* x_2542; lean_object* x_2543; lean_object* x_2544; lean_object* x_2545; lean_object* x_2546; lean_object* x_2547; 
-x_2530 = lean_ctor_get(x_234, 0);
-x_2531 = lean_ctor_get(x_234, 1);
-x_2532 = lean_ctor_get(x_234, 2);
-x_2533 = lean_ctor_get(x_234, 3);
-x_2534 = lean_ctor_get(x_1265, 0);
-x_2535 = lean_ctor_get(x_1265, 1);
-x_2536 = lean_ctor_get(x_1265, 2);
-x_2537 = lean_ctor_get(x_1265, 3);
-x_2538 = lean_ctor_get(x_4, 1);
-x_2539 = lean_ctor_get(x_4, 2);
-lean_inc(x_2539);
-lean_inc(x_2538);
-lean_dec(x_4);
-x_2540 = lean_ctor_get(x_2428, 0);
-lean_inc(x_2540);
-x_2541 = lean_ctor_get(x_2428, 1);
-lean_inc(x_2541);
-x_2542 = lean_ctor_get(x_2428, 2);
-lean_inc(x_2542);
-x_2543 = lean_ctor_get(x_2428, 3);
-lean_inc(x_2543);
-if (lean_is_exclusive(x_2428)) {
- lean_ctor_release(x_2428, 0);
- lean_ctor_release(x_2428, 1);
- lean_ctor_release(x_2428, 2);
- lean_ctor_release(x_2428, 3);
- x_2544 = x_2428;
-} else {
- lean_dec_ref(x_2428);
- x_2544 = lean_box(0);
-}
-if (lean_is_scalar(x_2544)) {
- x_2545 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2545 = x_2544;
-}
-lean_ctor_set(x_2545, 0, x_2530);
-lean_ctor_set(x_2545, 1, x_2531);
-lean_ctor_set(x_2545, 2, x_2532);
-lean_ctor_set(x_2545, 3, x_2533);
-lean_ctor_set_uint8(x_2545, sizeof(void*)*4, x_2095);
-x_2546 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2546, 0, x_2534);
-lean_ctor_set(x_2546, 1, x_2535);
-lean_ctor_set(x_2546, 2, x_2536);
-lean_ctor_set(x_2546, 3, x_2537);
-lean_ctor_set_uint8(x_2546, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1265, 3, x_2546);
-lean_ctor_set(x_1265, 2, x_2500);
-lean_ctor_set(x_1265, 1, x_2499);
-lean_ctor_set(x_1265, 0, x_2545);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_234, 3, x_1890);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_1265);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1, 3, x_2543);
-lean_ctor_set(x_1, 2, x_2542);
-lean_ctor_set(x_1, 1, x_2541);
-lean_ctor_set(x_1, 0, x_2540);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-x_2547 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2547, 0, x_234);
-lean_ctor_set(x_2547, 1, x_2538);
-lean_ctor_set(x_2547, 2, x_2539);
-lean_ctor_set(x_2547, 3, x_1);
-lean_ctor_set_uint8(x_2547, sizeof(void*)*4, x_2497);
-return x_2547;
-}
-}
-else
-{
-lean_object* x_2548; lean_object* x_2549; lean_object* x_2550; lean_object* x_2551; lean_object* x_2552; lean_object* x_2553; lean_object* x_2554; lean_object* x_2555; lean_object* x_2556; lean_object* x_2557; lean_object* x_2558; lean_object* x_2559; lean_object* x_2560; lean_object* x_2561; lean_object* x_2562; lean_object* x_2563; lean_object* x_2564; lean_object* x_2565; lean_object* x_2566; lean_object* x_2567; 
-x_2548 = lean_ctor_get(x_234, 0);
-x_2549 = lean_ctor_get(x_234, 1);
-x_2550 = lean_ctor_get(x_234, 2);
-x_2551 = lean_ctor_get(x_234, 3);
-x_2552 = lean_ctor_get(x_1265, 0);
-x_2553 = lean_ctor_get(x_1265, 1);
-x_2554 = lean_ctor_get(x_1265, 2);
-x_2555 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2555);
-lean_inc(x_2554);
-lean_inc(x_2553);
-lean_inc(x_2552);
-lean_dec(x_1265);
-x_2556 = lean_ctor_get(x_4, 1);
-lean_inc(x_2556);
-x_2557 = lean_ctor_get(x_4, 2);
-lean_inc(x_2557);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2558 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2558 = lean_box(0);
-}
-x_2559 = lean_ctor_get(x_2428, 0);
-lean_inc(x_2559);
-x_2560 = lean_ctor_get(x_2428, 1);
-lean_inc(x_2560);
-x_2561 = lean_ctor_get(x_2428, 2);
-lean_inc(x_2561);
-x_2562 = lean_ctor_get(x_2428, 3);
-lean_inc(x_2562);
-if (lean_is_exclusive(x_2428)) {
- lean_ctor_release(x_2428, 0);
- lean_ctor_release(x_2428, 1);
- lean_ctor_release(x_2428, 2);
- lean_ctor_release(x_2428, 3);
- x_2563 = x_2428;
-} else {
- lean_dec_ref(x_2428);
- x_2563 = lean_box(0);
-}
-if (lean_is_scalar(x_2563)) {
- x_2564 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2564 = x_2563;
-}
-lean_ctor_set(x_2564, 0, x_2548);
-lean_ctor_set(x_2564, 1, x_2549);
-lean_ctor_set(x_2564, 2, x_2550);
-lean_ctor_set(x_2564, 3, x_2551);
-lean_ctor_set_uint8(x_2564, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2558)) {
- x_2565 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2565 = x_2558;
-}
-lean_ctor_set(x_2565, 0, x_2552);
-lean_ctor_set(x_2565, 1, x_2553);
-lean_ctor_set(x_2565, 2, x_2554);
-lean_ctor_set(x_2565, 3, x_2555);
-lean_ctor_set_uint8(x_2565, sizeof(void*)*4, x_2095);
-x_2566 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2566, 0, x_2564);
-lean_ctor_set(x_2566, 1, x_2499);
-lean_ctor_set(x_2566, 2, x_2500);
-lean_ctor_set(x_2566, 3, x_2565);
-lean_ctor_set_uint8(x_2566, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_234, 3, x_1890);
-lean_ctor_set(x_234, 2, x_3);
-lean_ctor_set(x_234, 1, x_2);
-lean_ctor_set(x_234, 0, x_2566);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1, 3, x_2562);
-lean_ctor_set(x_1, 2, x_2561);
-lean_ctor_set(x_1, 1, x_2560);
-lean_ctor_set(x_1, 0, x_2559);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-x_2567 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2567, 0, x_234);
-lean_ctor_set(x_2567, 1, x_2556);
-lean_ctor_set(x_2567, 2, x_2557);
-lean_ctor_set(x_2567, 3, x_1);
-lean_ctor_set_uint8(x_2567, sizeof(void*)*4, x_2497);
-return x_2567;
-}
-}
-else
-{
-lean_object* x_2568; lean_object* x_2569; lean_object* x_2570; lean_object* x_2571; lean_object* x_2572; lean_object* x_2573; lean_object* x_2574; lean_object* x_2575; lean_object* x_2576; lean_object* x_2577; lean_object* x_2578; lean_object* x_2579; lean_object* x_2580; lean_object* x_2581; lean_object* x_2582; lean_object* x_2583; lean_object* x_2584; lean_object* x_2585; lean_object* x_2586; lean_object* x_2587; lean_object* x_2588; lean_object* x_2589; 
-x_2568 = lean_ctor_get(x_234, 0);
-x_2569 = lean_ctor_get(x_234, 1);
-x_2570 = lean_ctor_get(x_234, 2);
-x_2571 = lean_ctor_get(x_234, 3);
-lean_inc(x_2571);
-lean_inc(x_2570);
-lean_inc(x_2569);
-lean_inc(x_2568);
-lean_dec(x_234);
-x_2572 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2572);
-x_2573 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2573);
-x_2574 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2574);
-x_2575 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2575);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2576 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2576 = lean_box(0);
-}
-x_2577 = lean_ctor_get(x_4, 1);
-lean_inc(x_2577);
-x_2578 = lean_ctor_get(x_4, 2);
-lean_inc(x_2578);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2579 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2579 = lean_box(0);
-}
-x_2580 = lean_ctor_get(x_2428, 0);
-lean_inc(x_2580);
-x_2581 = lean_ctor_get(x_2428, 1);
-lean_inc(x_2581);
-x_2582 = lean_ctor_get(x_2428, 2);
-lean_inc(x_2582);
-x_2583 = lean_ctor_get(x_2428, 3);
-lean_inc(x_2583);
-if (lean_is_exclusive(x_2428)) {
- lean_ctor_release(x_2428, 0);
- lean_ctor_release(x_2428, 1);
- lean_ctor_release(x_2428, 2);
- lean_ctor_release(x_2428, 3);
- x_2584 = x_2428;
-} else {
- lean_dec_ref(x_2428);
- x_2584 = lean_box(0);
-}
-if (lean_is_scalar(x_2584)) {
- x_2585 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2585 = x_2584;
-}
-lean_ctor_set(x_2585, 0, x_2568);
-lean_ctor_set(x_2585, 1, x_2569);
-lean_ctor_set(x_2585, 2, x_2570);
-lean_ctor_set(x_2585, 3, x_2571);
-lean_ctor_set_uint8(x_2585, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2579)) {
- x_2586 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2586 = x_2579;
-}
-lean_ctor_set(x_2586, 0, x_2572);
-lean_ctor_set(x_2586, 1, x_2573);
-lean_ctor_set(x_2586, 2, x_2574);
-lean_ctor_set(x_2586, 3, x_2575);
-lean_ctor_set_uint8(x_2586, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2576)) {
- x_2587 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2587 = x_2576;
-}
-lean_ctor_set(x_2587, 0, x_2585);
-lean_ctor_set(x_2587, 1, x_2499);
-lean_ctor_set(x_2587, 2, x_2500);
-lean_ctor_set(x_2587, 3, x_2586);
-lean_ctor_set_uint8(x_2587, sizeof(void*)*4, x_2497);
-x_2588 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2588, 0, x_2587);
-lean_ctor_set(x_2588, 1, x_2);
-lean_ctor_set(x_2588, 2, x_3);
-lean_ctor_set(x_2588, 3, x_1890);
-lean_ctor_set_uint8(x_2588, sizeof(void*)*4, x_2095);
-lean_ctor_set(x_1, 3, x_2583);
-lean_ctor_set(x_1, 2, x_2582);
-lean_ctor_set(x_1, 1, x_2581);
-lean_ctor_set(x_1, 0, x_2580);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2095);
-x_2589 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2589, 0, x_2588);
-lean_ctor_set(x_2589, 1, x_2577);
-lean_ctor_set(x_2589, 2, x_2578);
-lean_ctor_set(x_2589, 3, x_1);
-lean_ctor_set_uint8(x_2589, sizeof(void*)*4, x_2497);
-return x_2589;
-}
-}
-else
-{
-lean_object* x_2590; lean_object* x_2591; lean_object* x_2592; lean_object* x_2593; lean_object* x_2594; lean_object* x_2595; lean_object* x_2596; lean_object* x_2597; lean_object* x_2598; lean_object* x_2599; lean_object* x_2600; lean_object* x_2601; lean_object* x_2602; lean_object* x_2603; lean_object* x_2604; lean_object* x_2605; lean_object* x_2606; lean_object* x_2607; lean_object* x_2608; lean_object* x_2609; lean_object* x_2610; lean_object* x_2611; lean_object* x_2612; lean_object* x_2613; lean_object* x_2614; lean_object* x_2615; 
-x_2590 = lean_ctor_get(x_1, 1);
-x_2591 = lean_ctor_get(x_1, 2);
-lean_inc(x_2591);
-lean_inc(x_2590);
-lean_dec(x_1);
-x_2592 = lean_ctor_get(x_234, 0);
-lean_inc(x_2592);
-x_2593 = lean_ctor_get(x_234, 1);
-lean_inc(x_2593);
-x_2594 = lean_ctor_get(x_234, 2);
-lean_inc(x_2594);
-x_2595 = lean_ctor_get(x_234, 3);
-lean_inc(x_2595);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2596 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2596 = lean_box(0);
-}
-x_2597 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2597);
-x_2598 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2598);
-x_2599 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2599);
-x_2600 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2600);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2601 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2601 = lean_box(0);
-}
-x_2602 = lean_ctor_get(x_4, 1);
-lean_inc(x_2602);
-x_2603 = lean_ctor_get(x_4, 2);
-lean_inc(x_2603);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2604 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2604 = lean_box(0);
-}
-x_2605 = lean_ctor_get(x_2428, 0);
-lean_inc(x_2605);
-x_2606 = lean_ctor_get(x_2428, 1);
-lean_inc(x_2606);
-x_2607 = lean_ctor_get(x_2428, 2);
-lean_inc(x_2607);
-x_2608 = lean_ctor_get(x_2428, 3);
-lean_inc(x_2608);
-if (lean_is_exclusive(x_2428)) {
- lean_ctor_release(x_2428, 0);
- lean_ctor_release(x_2428, 1);
- lean_ctor_release(x_2428, 2);
- lean_ctor_release(x_2428, 3);
- x_2609 = x_2428;
-} else {
- lean_dec_ref(x_2428);
- x_2609 = lean_box(0);
-}
-if (lean_is_scalar(x_2609)) {
- x_2610 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2610 = x_2609;
-}
-lean_ctor_set(x_2610, 0, x_2592);
-lean_ctor_set(x_2610, 1, x_2593);
-lean_ctor_set(x_2610, 2, x_2594);
-lean_ctor_set(x_2610, 3, x_2595);
-lean_ctor_set_uint8(x_2610, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2604)) {
- x_2611 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2611 = x_2604;
-}
-lean_ctor_set(x_2611, 0, x_2597);
-lean_ctor_set(x_2611, 1, x_2598);
-lean_ctor_set(x_2611, 2, x_2599);
-lean_ctor_set(x_2611, 3, x_2600);
-lean_ctor_set_uint8(x_2611, sizeof(void*)*4, x_2095);
-if (lean_is_scalar(x_2601)) {
- x_2612 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2612 = x_2601;
-}
-lean_ctor_set(x_2612, 0, x_2610);
-lean_ctor_set(x_2612, 1, x_2590);
-lean_ctor_set(x_2612, 2, x_2591);
-lean_ctor_set(x_2612, 3, x_2611);
-lean_ctor_set_uint8(x_2612, sizeof(void*)*4, x_2497);
-if (lean_is_scalar(x_2596)) {
- x_2613 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2613 = x_2596;
-}
-lean_ctor_set(x_2613, 0, x_2612);
-lean_ctor_set(x_2613, 1, x_2);
-lean_ctor_set(x_2613, 2, x_3);
-lean_ctor_set(x_2613, 3, x_1890);
-lean_ctor_set_uint8(x_2613, sizeof(void*)*4, x_2095);
-x_2614 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2614, 0, x_2605);
-lean_ctor_set(x_2614, 1, x_2606);
-lean_ctor_set(x_2614, 2, x_2607);
-lean_ctor_set(x_2614, 3, x_2608);
-lean_ctor_set_uint8(x_2614, sizeof(void*)*4, x_2095);
-x_2615 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2615, 0, x_2613);
-lean_ctor_set(x_2615, 1, x_2602);
-lean_ctor_set(x_2615, 2, x_2603);
-lean_ctor_set(x_2615, 3, x_2614);
-lean_ctor_set_uint8(x_2615, sizeof(void*)*4, x_2497);
-return x_2615;
-}
-}
-else
-{
-uint8_t x_2616; 
-x_2616 = !lean_is_exclusive(x_1);
-if (x_2616 == 0)
-{
-lean_object* x_2617; lean_object* x_2618; lean_object* x_2619; lean_object* x_2620; uint8_t x_2621; 
-x_2617 = lean_ctor_get(x_1, 1);
-x_2618 = lean_ctor_get(x_1, 2);
-x_2619 = lean_ctor_get(x_1, 3);
-lean_dec(x_2619);
-x_2620 = lean_ctor_get(x_1, 0);
-lean_dec(x_2620);
-x_2621 = !lean_is_exclusive(x_234);
-if (x_2621 == 0)
-{
-uint8_t x_2622; 
-x_2622 = !lean_is_exclusive(x_1265);
-if (x_2622 == 0)
-{
-uint8_t x_2623; 
-x_2623 = !lean_is_exclusive(x_4);
-if (x_2623 == 0)
-{
-lean_object* x_2624; lean_object* x_2625; lean_object* x_2626; lean_object* x_2627; lean_object* x_2628; lean_object* x_2629; lean_object* x_2630; lean_object* x_2631; lean_object* x_2632; lean_object* x_2633; lean_object* x_2634; lean_object* x_2635; uint8_t x_2636; 
-x_2624 = lean_ctor_get(x_234, 0);
-x_2625 = lean_ctor_get(x_234, 1);
-x_2626 = lean_ctor_get(x_234, 2);
-x_2627 = lean_ctor_get(x_234, 3);
-x_2628 = lean_ctor_get(x_1265, 0);
-x_2629 = lean_ctor_get(x_1265, 1);
-x_2630 = lean_ctor_get(x_1265, 2);
-x_2631 = lean_ctor_get(x_1265, 3);
-x_2632 = lean_ctor_get(x_4, 1);
-x_2633 = lean_ctor_get(x_4, 2);
-x_2634 = lean_ctor_get(x_4, 3);
-lean_dec(x_2634);
-x_2635 = lean_ctor_get(x_4, 0);
-lean_dec(x_2635);
-x_2636 = !lean_is_exclusive(x_1890);
-if (x_2636 == 0)
-{
-lean_object* x_2637; lean_object* x_2638; lean_object* x_2639; lean_object* x_2640; lean_object* x_2641; 
-x_2637 = lean_ctor_get(x_1890, 0);
-x_2638 = lean_ctor_get(x_1890, 1);
-x_2639 = lean_ctor_get(x_1890, 2);
-x_2640 = lean_ctor_get(x_1890, 3);
-lean_ctor_set(x_1890, 3, x_2627);
-lean_ctor_set(x_1890, 2, x_2626);
-lean_ctor_set(x_1890, 1, x_2625);
-lean_ctor_set(x_1890, 0, x_2624);
-lean_ctor_set_uint8(x_1890, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_4, 3, x_2631);
-lean_ctor_set(x_4, 2, x_2630);
-lean_ctor_set(x_4, 1, x_2629);
-lean_ctor_set(x_4, 0, x_2628);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1265, 3, x_4);
-lean_ctor_set(x_1265, 2, x_2618);
-lean_ctor_set(x_1265, 1, x_2617);
-lean_ctor_set(x_1265, 0, x_1890);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_234, 3, x_2640);
-lean_ctor_set(x_234, 2, x_2639);
-lean_ctor_set(x_234, 1, x_2638);
-lean_ctor_set(x_234, 0, x_2637);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1, 3, x_2428);
-lean_ctor_set(x_1, 2, x_2633);
-lean_ctor_set(x_1, 1, x_2632);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_2641 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2641, 0, x_1265);
-lean_ctor_set(x_2641, 1, x_2);
-lean_ctor_set(x_2641, 2, x_3);
-lean_ctor_set(x_2641, 3, x_1);
-lean_ctor_set_uint8(x_2641, sizeof(void*)*4, x_2497);
-return x_2641;
-}
-else
-{
-lean_object* x_2642; lean_object* x_2643; lean_object* x_2644; lean_object* x_2645; lean_object* x_2646; lean_object* x_2647; 
-x_2642 = lean_ctor_get(x_1890, 0);
-x_2643 = lean_ctor_get(x_1890, 1);
-x_2644 = lean_ctor_get(x_1890, 2);
-x_2645 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2645);
-lean_inc(x_2644);
-lean_inc(x_2643);
-lean_inc(x_2642);
-lean_dec(x_1890);
-x_2646 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2646, 0, x_2624);
-lean_ctor_set(x_2646, 1, x_2625);
-lean_ctor_set(x_2646, 2, x_2626);
-lean_ctor_set(x_2646, 3, x_2627);
-lean_ctor_set_uint8(x_2646, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_4, 3, x_2631);
-lean_ctor_set(x_4, 2, x_2630);
-lean_ctor_set(x_4, 1, x_2629);
-lean_ctor_set(x_4, 0, x_2628);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1265, 3, x_4);
-lean_ctor_set(x_1265, 2, x_2618);
-lean_ctor_set(x_1265, 1, x_2617);
-lean_ctor_set(x_1265, 0, x_2646);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_234, 3, x_2645);
-lean_ctor_set(x_234, 2, x_2644);
-lean_ctor_set(x_234, 1, x_2643);
-lean_ctor_set(x_234, 0, x_2642);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1, 3, x_2428);
-lean_ctor_set(x_1, 2, x_2633);
-lean_ctor_set(x_1, 1, x_2632);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_2647 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2647, 0, x_1265);
-lean_ctor_set(x_2647, 1, x_2);
-lean_ctor_set(x_2647, 2, x_3);
-lean_ctor_set(x_2647, 3, x_1);
-lean_ctor_set_uint8(x_2647, sizeof(void*)*4, x_2497);
-return x_2647;
-}
-}
-else
-{
-lean_object* x_2648; lean_object* x_2649; lean_object* x_2650; lean_object* x_2651; lean_object* x_2652; lean_object* x_2653; lean_object* x_2654; lean_object* x_2655; lean_object* x_2656; lean_object* x_2657; lean_object* x_2658; lean_object* x_2659; lean_object* x_2660; lean_object* x_2661; lean_object* x_2662; lean_object* x_2663; lean_object* x_2664; lean_object* x_2665; 
-x_2648 = lean_ctor_get(x_234, 0);
-x_2649 = lean_ctor_get(x_234, 1);
-x_2650 = lean_ctor_get(x_234, 2);
-x_2651 = lean_ctor_get(x_234, 3);
-x_2652 = lean_ctor_get(x_1265, 0);
-x_2653 = lean_ctor_get(x_1265, 1);
-x_2654 = lean_ctor_get(x_1265, 2);
-x_2655 = lean_ctor_get(x_1265, 3);
-x_2656 = lean_ctor_get(x_4, 1);
-x_2657 = lean_ctor_get(x_4, 2);
-lean_inc(x_2657);
-lean_inc(x_2656);
-lean_dec(x_4);
-x_2658 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2658);
-x_2659 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2659);
-x_2660 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2660);
-x_2661 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2661);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2662 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2662 = lean_box(0);
-}
-if (lean_is_scalar(x_2662)) {
- x_2663 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2663 = x_2662;
-}
-lean_ctor_set(x_2663, 0, x_2648);
-lean_ctor_set(x_2663, 1, x_2649);
-lean_ctor_set(x_2663, 2, x_2650);
-lean_ctor_set(x_2663, 3, x_2651);
-lean_ctor_set_uint8(x_2663, sizeof(void*)*4, x_2497);
-x_2664 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2664, 0, x_2652);
-lean_ctor_set(x_2664, 1, x_2653);
-lean_ctor_set(x_2664, 2, x_2654);
-lean_ctor_set(x_2664, 3, x_2655);
-lean_ctor_set_uint8(x_2664, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1265, 3, x_2664);
-lean_ctor_set(x_1265, 2, x_2618);
-lean_ctor_set(x_1265, 1, x_2617);
-lean_ctor_set(x_1265, 0, x_2663);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_234, 3, x_2661);
-lean_ctor_set(x_234, 2, x_2660);
-lean_ctor_set(x_234, 1, x_2659);
-lean_ctor_set(x_234, 0, x_2658);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1, 3, x_2428);
-lean_ctor_set(x_1, 2, x_2657);
-lean_ctor_set(x_1, 1, x_2656);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_2665 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2665, 0, x_1265);
-lean_ctor_set(x_2665, 1, x_2);
-lean_ctor_set(x_2665, 2, x_3);
-lean_ctor_set(x_2665, 3, x_1);
-lean_ctor_set_uint8(x_2665, sizeof(void*)*4, x_2497);
-return x_2665;
-}
-}
-else
-{
-lean_object* x_2666; lean_object* x_2667; lean_object* x_2668; lean_object* x_2669; lean_object* x_2670; lean_object* x_2671; lean_object* x_2672; lean_object* x_2673; lean_object* x_2674; lean_object* x_2675; lean_object* x_2676; lean_object* x_2677; lean_object* x_2678; lean_object* x_2679; lean_object* x_2680; lean_object* x_2681; lean_object* x_2682; lean_object* x_2683; lean_object* x_2684; lean_object* x_2685; 
-x_2666 = lean_ctor_get(x_234, 0);
-x_2667 = lean_ctor_get(x_234, 1);
-x_2668 = lean_ctor_get(x_234, 2);
-x_2669 = lean_ctor_get(x_234, 3);
-x_2670 = lean_ctor_get(x_1265, 0);
-x_2671 = lean_ctor_get(x_1265, 1);
-x_2672 = lean_ctor_get(x_1265, 2);
-x_2673 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2673);
-lean_inc(x_2672);
-lean_inc(x_2671);
-lean_inc(x_2670);
-lean_dec(x_1265);
-x_2674 = lean_ctor_get(x_4, 1);
-lean_inc(x_2674);
-x_2675 = lean_ctor_get(x_4, 2);
-lean_inc(x_2675);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2676 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2676 = lean_box(0);
-}
-x_2677 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2677);
-x_2678 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2678);
-x_2679 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2679);
-x_2680 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2680);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2681 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2681 = lean_box(0);
-}
-if (lean_is_scalar(x_2681)) {
- x_2682 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2682 = x_2681;
-}
-lean_ctor_set(x_2682, 0, x_2666);
-lean_ctor_set(x_2682, 1, x_2667);
-lean_ctor_set(x_2682, 2, x_2668);
-lean_ctor_set(x_2682, 3, x_2669);
-lean_ctor_set_uint8(x_2682, sizeof(void*)*4, x_2497);
-if (lean_is_scalar(x_2676)) {
- x_2683 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2683 = x_2676;
-}
-lean_ctor_set(x_2683, 0, x_2670);
-lean_ctor_set(x_2683, 1, x_2671);
-lean_ctor_set(x_2683, 2, x_2672);
-lean_ctor_set(x_2683, 3, x_2673);
-lean_ctor_set_uint8(x_2683, sizeof(void*)*4, x_2497);
-x_2684 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2684, 0, x_2682);
-lean_ctor_set(x_2684, 1, x_2617);
-lean_ctor_set(x_2684, 2, x_2618);
-lean_ctor_set(x_2684, 3, x_2683);
-lean_ctor_set_uint8(x_2684, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_234, 3, x_2680);
-lean_ctor_set(x_234, 2, x_2679);
-lean_ctor_set(x_234, 1, x_2678);
-lean_ctor_set(x_234, 0, x_2677);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1, 3, x_2428);
-lean_ctor_set(x_1, 2, x_2675);
-lean_ctor_set(x_1, 1, x_2674);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_2685 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2685, 0, x_2684);
-lean_ctor_set(x_2685, 1, x_2);
-lean_ctor_set(x_2685, 2, x_3);
-lean_ctor_set(x_2685, 3, x_1);
-lean_ctor_set_uint8(x_2685, sizeof(void*)*4, x_2497);
-return x_2685;
-}
-}
-else
-{
-lean_object* x_2686; lean_object* x_2687; lean_object* x_2688; lean_object* x_2689; lean_object* x_2690; lean_object* x_2691; lean_object* x_2692; lean_object* x_2693; lean_object* x_2694; lean_object* x_2695; lean_object* x_2696; lean_object* x_2697; lean_object* x_2698; lean_object* x_2699; lean_object* x_2700; lean_object* x_2701; lean_object* x_2702; lean_object* x_2703; lean_object* x_2704; lean_object* x_2705; lean_object* x_2706; lean_object* x_2707; 
-x_2686 = lean_ctor_get(x_234, 0);
-x_2687 = lean_ctor_get(x_234, 1);
-x_2688 = lean_ctor_get(x_234, 2);
-x_2689 = lean_ctor_get(x_234, 3);
-lean_inc(x_2689);
-lean_inc(x_2688);
-lean_inc(x_2687);
-lean_inc(x_2686);
-lean_dec(x_234);
-x_2690 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2690);
-x_2691 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2691);
-x_2692 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2692);
-x_2693 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2693);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2694 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2694 = lean_box(0);
-}
-x_2695 = lean_ctor_get(x_4, 1);
-lean_inc(x_2695);
-x_2696 = lean_ctor_get(x_4, 2);
-lean_inc(x_2696);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2697 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2697 = lean_box(0);
-}
-x_2698 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2698);
-x_2699 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2699);
-x_2700 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2700);
-x_2701 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2701);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2702 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2702 = lean_box(0);
-}
-if (lean_is_scalar(x_2702)) {
- x_2703 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2703 = x_2702;
-}
-lean_ctor_set(x_2703, 0, x_2686);
-lean_ctor_set(x_2703, 1, x_2687);
-lean_ctor_set(x_2703, 2, x_2688);
-lean_ctor_set(x_2703, 3, x_2689);
-lean_ctor_set_uint8(x_2703, sizeof(void*)*4, x_2497);
-if (lean_is_scalar(x_2697)) {
- x_2704 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2704 = x_2697;
-}
-lean_ctor_set(x_2704, 0, x_2690);
-lean_ctor_set(x_2704, 1, x_2691);
-lean_ctor_set(x_2704, 2, x_2692);
-lean_ctor_set(x_2704, 3, x_2693);
-lean_ctor_set_uint8(x_2704, sizeof(void*)*4, x_2497);
-if (lean_is_scalar(x_2694)) {
- x_2705 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2705 = x_2694;
-}
-lean_ctor_set(x_2705, 0, x_2703);
-lean_ctor_set(x_2705, 1, x_2617);
-lean_ctor_set(x_2705, 2, x_2618);
-lean_ctor_set(x_2705, 3, x_2704);
-lean_ctor_set_uint8(x_2705, sizeof(void*)*4, x_1889);
-x_2706 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2706, 0, x_2698);
-lean_ctor_set(x_2706, 1, x_2699);
-lean_ctor_set(x_2706, 2, x_2700);
-lean_ctor_set(x_2706, 3, x_2701);
-lean_ctor_set_uint8(x_2706, sizeof(void*)*4, x_2497);
-lean_ctor_set(x_1, 3, x_2428);
-lean_ctor_set(x_1, 2, x_2696);
-lean_ctor_set(x_1, 1, x_2695);
-lean_ctor_set(x_1, 0, x_2706);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_1889);
-x_2707 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2707, 0, x_2705);
-lean_ctor_set(x_2707, 1, x_2);
-lean_ctor_set(x_2707, 2, x_3);
-lean_ctor_set(x_2707, 3, x_1);
-lean_ctor_set_uint8(x_2707, sizeof(void*)*4, x_2497);
-return x_2707;
-}
-}
-else
-{
-lean_object* x_2708; lean_object* x_2709; lean_object* x_2710; lean_object* x_2711; lean_object* x_2712; lean_object* x_2713; lean_object* x_2714; lean_object* x_2715; lean_object* x_2716; lean_object* x_2717; lean_object* x_2718; lean_object* x_2719; lean_object* x_2720; lean_object* x_2721; lean_object* x_2722; lean_object* x_2723; lean_object* x_2724; lean_object* x_2725; lean_object* x_2726; lean_object* x_2727; lean_object* x_2728; lean_object* x_2729; lean_object* x_2730; lean_object* x_2731; lean_object* x_2732; lean_object* x_2733; 
-x_2708 = lean_ctor_get(x_1, 1);
-x_2709 = lean_ctor_get(x_1, 2);
-lean_inc(x_2709);
-lean_inc(x_2708);
-lean_dec(x_1);
-x_2710 = lean_ctor_get(x_234, 0);
-lean_inc(x_2710);
-x_2711 = lean_ctor_get(x_234, 1);
-lean_inc(x_2711);
-x_2712 = lean_ctor_get(x_234, 2);
-lean_inc(x_2712);
-x_2713 = lean_ctor_get(x_234, 3);
-lean_inc(x_2713);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2714 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2714 = lean_box(0);
-}
-x_2715 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2715);
-x_2716 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2716);
-x_2717 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2717);
-x_2718 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2718);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2719 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2719 = lean_box(0);
-}
-x_2720 = lean_ctor_get(x_4, 1);
-lean_inc(x_2720);
-x_2721 = lean_ctor_get(x_4, 2);
-lean_inc(x_2721);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2722 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2722 = lean_box(0);
-}
-x_2723 = lean_ctor_get(x_1890, 0);
-lean_inc(x_2723);
-x_2724 = lean_ctor_get(x_1890, 1);
-lean_inc(x_2724);
-x_2725 = lean_ctor_get(x_1890, 2);
-lean_inc(x_2725);
-x_2726 = lean_ctor_get(x_1890, 3);
-lean_inc(x_2726);
-if (lean_is_exclusive(x_1890)) {
- lean_ctor_release(x_1890, 0);
- lean_ctor_release(x_1890, 1);
- lean_ctor_release(x_1890, 2);
- lean_ctor_release(x_1890, 3);
- x_2727 = x_1890;
-} else {
- lean_dec_ref(x_1890);
- x_2727 = lean_box(0);
-}
-if (lean_is_scalar(x_2727)) {
- x_2728 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2728 = x_2727;
-}
-lean_ctor_set(x_2728, 0, x_2710);
-lean_ctor_set(x_2728, 1, x_2711);
-lean_ctor_set(x_2728, 2, x_2712);
-lean_ctor_set(x_2728, 3, x_2713);
-lean_ctor_set_uint8(x_2728, sizeof(void*)*4, x_2497);
-if (lean_is_scalar(x_2722)) {
- x_2729 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2729 = x_2722;
-}
-lean_ctor_set(x_2729, 0, x_2715);
-lean_ctor_set(x_2729, 1, x_2716);
-lean_ctor_set(x_2729, 2, x_2717);
-lean_ctor_set(x_2729, 3, x_2718);
-lean_ctor_set_uint8(x_2729, sizeof(void*)*4, x_2497);
-if (lean_is_scalar(x_2719)) {
- x_2730 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2730 = x_2719;
-}
-lean_ctor_set(x_2730, 0, x_2728);
-lean_ctor_set(x_2730, 1, x_2708);
-lean_ctor_set(x_2730, 2, x_2709);
-lean_ctor_set(x_2730, 3, x_2729);
-lean_ctor_set_uint8(x_2730, sizeof(void*)*4, x_1889);
-if (lean_is_scalar(x_2714)) {
- x_2731 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2731 = x_2714;
-}
-lean_ctor_set(x_2731, 0, x_2723);
-lean_ctor_set(x_2731, 1, x_2724);
-lean_ctor_set(x_2731, 2, x_2725);
-lean_ctor_set(x_2731, 3, x_2726);
-lean_ctor_set_uint8(x_2731, sizeof(void*)*4, x_2497);
-x_2732 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2732, 0, x_2731);
-lean_ctor_set(x_2732, 1, x_2720);
-lean_ctor_set(x_2732, 2, x_2721);
-lean_ctor_set(x_2732, 3, x_2428);
-lean_ctor_set_uint8(x_2732, sizeof(void*)*4, x_1889);
-x_2733 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2733, 0, x_2730);
-lean_ctor_set(x_2733, 1, x_2);
-lean_ctor_set(x_2733, 2, x_3);
-lean_ctor_set(x_2733, 3, x_2732);
-lean_ctor_set_uint8(x_2733, sizeof(void*)*4, x_2497);
-return x_2733;
-}
-}
-}
-}
-}
-}
-else
-{
-uint8_t x_2734; 
-x_2734 = !lean_is_exclusive(x_1);
-if (x_2734 == 0)
-{
-lean_object* x_2735; lean_object* x_2736; uint8_t x_2737; 
-x_2735 = lean_ctor_get(x_1, 3);
-lean_dec(x_2735);
-x_2736 = lean_ctor_get(x_1, 0);
-lean_dec(x_2736);
-x_2737 = !lean_is_exclusive(x_234);
-if (x_2737 == 0)
-{
-uint8_t x_2738; 
-x_2738 = !lean_is_exclusive(x_1265);
-if (x_2738 == 0)
-{
-lean_object* x_2739; lean_object* x_2740; lean_object* x_2741; lean_object* x_2742; lean_object* x_2743; lean_object* x_2744; lean_object* x_2745; lean_object* x_2746; lean_object* x_2747; 
-x_2739 = lean_ctor_get(x_234, 0);
-x_2740 = lean_ctor_get(x_234, 1);
-x_2741 = lean_ctor_get(x_234, 2);
-x_2742 = lean_ctor_get(x_234, 3);
-x_2743 = lean_ctor_get(x_1265, 0);
-x_2744 = lean_ctor_get(x_1265, 1);
-x_2745 = lean_ctor_get(x_1265, 2);
-x_2746 = lean_ctor_get(x_1265, 3);
-lean_ctor_set(x_1265, 3, x_2742);
-lean_ctor_set(x_1265, 2, x_2741);
-lean_ctor_set(x_1265, 1, x_2740);
-lean_ctor_set(x_1265, 0, x_2739);
-lean_ctor_set_uint8(x_1265, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_234, 3, x_2746);
-lean_ctor_set(x_234, 2, x_2745);
-lean_ctor_set(x_234, 1, x_2744);
-lean_ctor_set(x_234, 0, x_2743);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 0, x_1265);
-x_2747 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2747, 0, x_1);
-lean_ctor_set(x_2747, 1, x_2);
-lean_ctor_set(x_2747, 2, x_3);
-lean_ctor_set(x_2747, 3, x_4);
-lean_ctor_set_uint8(x_2747, sizeof(void*)*4, x_1889);
-return x_2747;
-}
-else
-{
-lean_object* x_2748; lean_object* x_2749; lean_object* x_2750; lean_object* x_2751; lean_object* x_2752; lean_object* x_2753; lean_object* x_2754; lean_object* x_2755; lean_object* x_2756; lean_object* x_2757; 
-x_2748 = lean_ctor_get(x_234, 0);
-x_2749 = lean_ctor_get(x_234, 1);
-x_2750 = lean_ctor_get(x_234, 2);
-x_2751 = lean_ctor_get(x_234, 3);
-x_2752 = lean_ctor_get(x_1265, 0);
-x_2753 = lean_ctor_get(x_1265, 1);
-x_2754 = lean_ctor_get(x_1265, 2);
-x_2755 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2755);
-lean_inc(x_2754);
-lean_inc(x_2753);
-lean_inc(x_2752);
-lean_dec(x_1265);
-x_2756 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2756, 0, x_2748);
-lean_ctor_set(x_2756, 1, x_2749);
-lean_ctor_set(x_2756, 2, x_2750);
-lean_ctor_set(x_2756, 3, x_2751);
-lean_ctor_set_uint8(x_2756, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_234, 3, x_2755);
-lean_ctor_set(x_234, 2, x_2754);
-lean_ctor_set(x_234, 1, x_2753);
-lean_ctor_set(x_234, 0, x_2752);
-lean_ctor_set_uint8(x_234, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_234);
-lean_ctor_set(x_1, 0, x_2756);
-x_2757 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2757, 0, x_1);
-lean_ctor_set(x_2757, 1, x_2);
-lean_ctor_set(x_2757, 2, x_3);
-lean_ctor_set(x_2757, 3, x_4);
-lean_ctor_set_uint8(x_2757, sizeof(void*)*4, x_1889);
-return x_2757;
-}
-}
-else
-{
-lean_object* x_2758; lean_object* x_2759; lean_object* x_2760; lean_object* x_2761; lean_object* x_2762; lean_object* x_2763; lean_object* x_2764; lean_object* x_2765; lean_object* x_2766; lean_object* x_2767; lean_object* x_2768; lean_object* x_2769; 
-x_2758 = lean_ctor_get(x_234, 0);
-x_2759 = lean_ctor_get(x_234, 1);
-x_2760 = lean_ctor_get(x_234, 2);
-x_2761 = lean_ctor_get(x_234, 3);
-lean_inc(x_2761);
-lean_inc(x_2760);
-lean_inc(x_2759);
-lean_inc(x_2758);
-lean_dec(x_234);
-x_2762 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2762);
-x_2763 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2763);
-x_2764 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2764);
-x_2765 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2765);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2766 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2766 = lean_box(0);
-}
-if (lean_is_scalar(x_2766)) {
- x_2767 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2767 = x_2766;
-}
-lean_ctor_set(x_2767, 0, x_2758);
-lean_ctor_set(x_2767, 1, x_2759);
-lean_ctor_set(x_2767, 2, x_2760);
-lean_ctor_set(x_2767, 3, x_2761);
-lean_ctor_set_uint8(x_2767, sizeof(void*)*4, x_1889);
-x_2768 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2768, 0, x_2762);
-lean_ctor_set(x_2768, 1, x_2763);
-lean_ctor_set(x_2768, 2, x_2764);
-lean_ctor_set(x_2768, 3, x_2765);
-lean_ctor_set_uint8(x_2768, sizeof(void*)*4, x_1889);
-lean_ctor_set(x_1, 3, x_2768);
-lean_ctor_set(x_1, 0, x_2767);
-x_2769 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2769, 0, x_1);
-lean_ctor_set(x_2769, 1, x_2);
-lean_ctor_set(x_2769, 2, x_3);
-lean_ctor_set(x_2769, 3, x_4);
-lean_ctor_set_uint8(x_2769, sizeof(void*)*4, x_1889);
-return x_2769;
-}
-}
-else
-{
-lean_object* x_2770; lean_object* x_2771; lean_object* x_2772; lean_object* x_2773; lean_object* x_2774; lean_object* x_2775; lean_object* x_2776; lean_object* x_2777; lean_object* x_2778; lean_object* x_2779; lean_object* x_2780; lean_object* x_2781; lean_object* x_2782; lean_object* x_2783; lean_object* x_2784; lean_object* x_2785; 
-x_2770 = lean_ctor_get(x_1, 1);
-x_2771 = lean_ctor_get(x_1, 2);
-lean_inc(x_2771);
-lean_inc(x_2770);
-lean_dec(x_1);
-x_2772 = lean_ctor_get(x_234, 0);
-lean_inc(x_2772);
-x_2773 = lean_ctor_get(x_234, 1);
-lean_inc(x_2773);
-x_2774 = lean_ctor_get(x_234, 2);
-lean_inc(x_2774);
-x_2775 = lean_ctor_get(x_234, 3);
-lean_inc(x_2775);
-if (lean_is_exclusive(x_234)) {
- lean_ctor_release(x_234, 0);
- lean_ctor_release(x_234, 1);
- lean_ctor_release(x_234, 2);
- lean_ctor_release(x_234, 3);
- x_2776 = x_234;
-} else {
- lean_dec_ref(x_234);
- x_2776 = lean_box(0);
-}
-x_2777 = lean_ctor_get(x_1265, 0);
-lean_inc(x_2777);
-x_2778 = lean_ctor_get(x_1265, 1);
-lean_inc(x_2778);
-x_2779 = lean_ctor_get(x_1265, 2);
-lean_inc(x_2779);
-x_2780 = lean_ctor_get(x_1265, 3);
-lean_inc(x_2780);
-if (lean_is_exclusive(x_1265)) {
- lean_ctor_release(x_1265, 0);
- lean_ctor_release(x_1265, 1);
- lean_ctor_release(x_1265, 2);
- lean_ctor_release(x_1265, 3);
- x_2781 = x_1265;
-} else {
- lean_dec_ref(x_1265);
- x_2781 = lean_box(0);
-}
-if (lean_is_scalar(x_2781)) {
- x_2782 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2782 = x_2781;
-}
-lean_ctor_set(x_2782, 0, x_2772);
-lean_ctor_set(x_2782, 1, x_2773);
-lean_ctor_set(x_2782, 2, x_2774);
-lean_ctor_set(x_2782, 3, x_2775);
-lean_ctor_set_uint8(x_2782, sizeof(void*)*4, x_1889);
-if (lean_is_scalar(x_2776)) {
- x_2783 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2783 = x_2776;
-}
-lean_ctor_set(x_2783, 0, x_2777);
-lean_ctor_set(x_2783, 1, x_2778);
-lean_ctor_set(x_2783, 2, x_2779);
-lean_ctor_set(x_2783, 3, x_2780);
-lean_ctor_set_uint8(x_2783, sizeof(void*)*4, x_1889);
-x_2784 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2784, 0, x_2782);
-lean_ctor_set(x_2784, 1, x_2770);
-lean_ctor_set(x_2784, 2, x_2771);
-lean_ctor_set(x_2784, 3, x_2783);
-lean_ctor_set_uint8(x_2784, sizeof(void*)*4, x_233);
-x_2785 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2785, 0, x_2784);
-lean_ctor_set(x_2785, 1, x_2);
-lean_ctor_set(x_2785, 2, x_3);
-lean_ctor_set(x_2785, 3, x_4);
-lean_ctor_set_uint8(x_2785, sizeof(void*)*4, x_1889);
-return x_2785;
-}
-}
-}
-}
-}
-}
-}
-}
-else
-{
-if (lean_obj_tag(x_4) == 0)
-{
-lean_object* x_2786; 
-x_2786 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2786, 0, x_1);
-lean_ctor_set(x_2786, 1, x_2);
-lean_ctor_set(x_2786, 2, x_3);
-lean_ctor_set(x_2786, 3, x_4);
-lean_ctor_set_uint8(x_2786, sizeof(void*)*4, x_233);
-return x_2786;
-}
-else
-{
-uint8_t x_2787; 
-x_2787 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
-if (x_2787 == 0)
-{
-lean_object* x_2788; 
-x_2788 = lean_ctor_get(x_4, 0);
-lean_inc(x_2788);
-if (lean_obj_tag(x_2788) == 0)
-{
-lean_object* x_2789; 
-x_2789 = lean_ctor_get(x_4, 3);
-lean_inc(x_2789);
-if (lean_obj_tag(x_2789) == 0)
-{
-uint8_t x_2790; 
-x_2790 = !lean_is_exclusive(x_4);
-if (x_2790 == 0)
-{
-lean_object* x_2791; lean_object* x_2792; lean_object* x_2793; 
-x_2791 = lean_ctor_get(x_4, 3);
-lean_dec(x_2791);
-x_2792 = lean_ctor_get(x_4, 0);
-lean_dec(x_2792);
-lean_ctor_set(x_4, 0, x_2789);
-x_2793 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2793, 0, x_1);
-lean_ctor_set(x_2793, 1, x_2);
-lean_ctor_set(x_2793, 2, x_3);
-lean_ctor_set(x_2793, 3, x_4);
-lean_ctor_set_uint8(x_2793, sizeof(void*)*4, x_233);
-return x_2793;
-}
-else
-{
-lean_object* x_2794; lean_object* x_2795; lean_object* x_2796; lean_object* x_2797; 
-x_2794 = lean_ctor_get(x_4, 1);
-x_2795 = lean_ctor_get(x_4, 2);
-lean_inc(x_2795);
-lean_inc(x_2794);
-lean_dec(x_4);
-x_2796 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2796, 0, x_2789);
-lean_ctor_set(x_2796, 1, x_2794);
-lean_ctor_set(x_2796, 2, x_2795);
-lean_ctor_set(x_2796, 3, x_2789);
-lean_ctor_set_uint8(x_2796, sizeof(void*)*4, x_2787);
-x_2797 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2797, 0, x_1);
-lean_ctor_set(x_2797, 1, x_2);
-lean_ctor_set(x_2797, 2, x_3);
-lean_ctor_set(x_2797, 3, x_2796);
-lean_ctor_set_uint8(x_2797, sizeof(void*)*4, x_233);
-return x_2797;
-}
-}
-else
-{
-uint8_t x_2798; 
-x_2798 = lean_ctor_get_uint8(x_2789, sizeof(void*)*4);
-if (x_2798 == 0)
-{
-uint8_t x_2799; 
-x_2799 = !lean_is_exclusive(x_4);
-if (x_2799 == 0)
-{
-lean_object* x_2800; lean_object* x_2801; lean_object* x_2802; lean_object* x_2803; uint8_t x_2804; 
-x_2800 = lean_ctor_get(x_4, 1);
-x_2801 = lean_ctor_get(x_4, 2);
-x_2802 = lean_ctor_get(x_4, 3);
-lean_dec(x_2802);
-x_2803 = lean_ctor_get(x_4, 0);
-lean_dec(x_2803);
-x_2804 = !lean_is_exclusive(x_2789);
-if (x_2804 == 0)
-{
-lean_object* x_2805; lean_object* x_2806; lean_object* x_2807; lean_object* x_2808; uint8_t x_2809; 
-x_2805 = lean_ctor_get(x_2789, 0);
-x_2806 = lean_ctor_get(x_2789, 1);
-x_2807 = lean_ctor_get(x_2789, 2);
-x_2808 = lean_ctor_get(x_2789, 3);
-lean_inc(x_1);
-lean_ctor_set(x_2789, 3, x_2788);
-lean_ctor_set(x_2789, 2, x_3);
-lean_ctor_set(x_2789, 1, x_2);
-lean_ctor_set(x_2789, 0, x_1);
-x_2809 = !lean_is_exclusive(x_1);
-if (x_2809 == 0)
-{
-lean_object* x_2810; lean_object* x_2811; lean_object* x_2812; lean_object* x_2813; 
-x_2810 = lean_ctor_get(x_1, 3);
-lean_dec(x_2810);
-x_2811 = lean_ctor_get(x_1, 2);
-lean_dec(x_2811);
-x_2812 = lean_ctor_get(x_1, 1);
-lean_dec(x_2812);
-x_2813 = lean_ctor_get(x_1, 0);
-lean_dec(x_2813);
-lean_ctor_set_uint8(x_2789, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 3, x_2808);
-lean_ctor_set(x_4, 2, x_2807);
-lean_ctor_set(x_4, 1, x_2806);
-lean_ctor_set(x_4, 0, x_2805);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_2801);
-lean_ctor_set(x_1, 1, x_2800);
-lean_ctor_set(x_1, 0, x_2789);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2798);
-return x_1;
-}
-else
-{
-lean_object* x_2814; 
-lean_dec(x_1);
-lean_ctor_set_uint8(x_2789, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 3, x_2808);
-lean_ctor_set(x_4, 2, x_2807);
-lean_ctor_set(x_4, 1, x_2806);
-lean_ctor_set(x_4, 0, x_2805);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-x_2814 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2814, 0, x_2789);
-lean_ctor_set(x_2814, 1, x_2800);
-lean_ctor_set(x_2814, 2, x_2801);
-lean_ctor_set(x_2814, 3, x_4);
-lean_ctor_set_uint8(x_2814, sizeof(void*)*4, x_2798);
-return x_2814;
-}
-}
-else
-{
-lean_object* x_2815; lean_object* x_2816; lean_object* x_2817; lean_object* x_2818; lean_object* x_2819; lean_object* x_2820; lean_object* x_2821; 
-x_2815 = lean_ctor_get(x_2789, 0);
-x_2816 = lean_ctor_get(x_2789, 1);
-x_2817 = lean_ctor_get(x_2789, 2);
-x_2818 = lean_ctor_get(x_2789, 3);
-lean_inc(x_2818);
-lean_inc(x_2817);
-lean_inc(x_2816);
-lean_inc(x_2815);
-lean_dec(x_2789);
-lean_inc(x_1);
-x_2819 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2819, 0, x_1);
-lean_ctor_set(x_2819, 1, x_2);
-lean_ctor_set(x_2819, 2, x_3);
-lean_ctor_set(x_2819, 3, x_2788);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2820 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2820 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2819, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 3, x_2818);
-lean_ctor_set(x_4, 2, x_2817);
-lean_ctor_set(x_4, 1, x_2816);
-lean_ctor_set(x_4, 0, x_2815);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-if (lean_is_scalar(x_2820)) {
- x_2821 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2821 = x_2820;
-}
-lean_ctor_set(x_2821, 0, x_2819);
-lean_ctor_set(x_2821, 1, x_2800);
-lean_ctor_set(x_2821, 2, x_2801);
-lean_ctor_set(x_2821, 3, x_4);
-lean_ctor_set_uint8(x_2821, sizeof(void*)*4, x_2798);
-return x_2821;
-}
-}
-else
-{
-lean_object* x_2822; lean_object* x_2823; lean_object* x_2824; lean_object* x_2825; lean_object* x_2826; lean_object* x_2827; lean_object* x_2828; lean_object* x_2829; lean_object* x_2830; lean_object* x_2831; lean_object* x_2832; 
-x_2822 = lean_ctor_get(x_4, 1);
-x_2823 = lean_ctor_get(x_4, 2);
-lean_inc(x_2823);
-lean_inc(x_2822);
-lean_dec(x_4);
-x_2824 = lean_ctor_get(x_2789, 0);
-lean_inc(x_2824);
-x_2825 = lean_ctor_get(x_2789, 1);
-lean_inc(x_2825);
-x_2826 = lean_ctor_get(x_2789, 2);
-lean_inc(x_2826);
-x_2827 = lean_ctor_get(x_2789, 3);
-lean_inc(x_2827);
-if (lean_is_exclusive(x_2789)) {
- lean_ctor_release(x_2789, 0);
- lean_ctor_release(x_2789, 1);
- lean_ctor_release(x_2789, 2);
- lean_ctor_release(x_2789, 3);
- x_2828 = x_2789;
-} else {
- lean_dec_ref(x_2789);
- x_2828 = lean_box(0);
-}
-lean_inc(x_1);
-if (lean_is_scalar(x_2828)) {
- x_2829 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2829 = x_2828;
-}
-lean_ctor_set(x_2829, 0, x_1);
-lean_ctor_set(x_2829, 1, x_2);
-lean_ctor_set(x_2829, 2, x_3);
-lean_ctor_set(x_2829, 3, x_2788);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2830 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2830 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2829, sizeof(void*)*4, x_233);
-x_2831 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2831, 0, x_2824);
-lean_ctor_set(x_2831, 1, x_2825);
-lean_ctor_set(x_2831, 2, x_2826);
-lean_ctor_set(x_2831, 3, x_2827);
-lean_ctor_set_uint8(x_2831, sizeof(void*)*4, x_233);
-if (lean_is_scalar(x_2830)) {
- x_2832 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2832 = x_2830;
-}
-lean_ctor_set(x_2832, 0, x_2829);
-lean_ctor_set(x_2832, 1, x_2822);
-lean_ctor_set(x_2832, 2, x_2823);
-lean_ctor_set(x_2832, 3, x_2831);
-lean_ctor_set_uint8(x_2832, sizeof(void*)*4, x_2798);
-return x_2832;
-}
-}
-else
-{
-uint8_t x_2833; 
-x_2833 = !lean_is_exclusive(x_2789);
-if (x_2833 == 0)
-{
-lean_object* x_2834; lean_object* x_2835; lean_object* x_2836; lean_object* x_2837; uint8_t x_2838; 
-x_2834 = lean_ctor_get(x_2789, 3);
-lean_dec(x_2834);
-x_2835 = lean_ctor_get(x_2789, 2);
-lean_dec(x_2835);
-x_2836 = lean_ctor_get(x_2789, 1);
-lean_dec(x_2836);
-x_2837 = lean_ctor_get(x_2789, 0);
-lean_dec(x_2837);
-x_2838 = !lean_is_exclusive(x_1);
-if (x_2838 == 0)
-{
-lean_object* x_2839; lean_object* x_2840; lean_object* x_2841; lean_object* x_2842; 
-x_2839 = lean_ctor_get(x_1, 0);
-x_2840 = lean_ctor_get(x_1, 1);
-x_2841 = lean_ctor_get(x_1, 2);
-x_2842 = lean_ctor_get(x_1, 3);
-lean_ctor_set(x_2789, 3, x_2842);
-lean_ctor_set(x_2789, 2, x_2841);
-lean_ctor_set(x_2789, 1, x_2840);
-lean_ctor_set(x_2789, 0, x_2839);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_2789);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2798);
-return x_1;
-}
-else
-{
-lean_object* x_2843; lean_object* x_2844; lean_object* x_2845; lean_object* x_2846; lean_object* x_2847; 
-x_2843 = lean_ctor_get(x_1, 0);
-x_2844 = lean_ctor_get(x_1, 1);
-x_2845 = lean_ctor_get(x_1, 2);
-x_2846 = lean_ctor_get(x_1, 3);
-lean_inc(x_2846);
-lean_inc(x_2845);
-lean_inc(x_2844);
-lean_inc(x_2843);
-lean_dec(x_1);
-lean_ctor_set(x_2789, 3, x_2846);
-lean_ctor_set(x_2789, 2, x_2845);
-lean_ctor_set(x_2789, 1, x_2844);
-lean_ctor_set(x_2789, 0, x_2843);
-x_2847 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2847, 0, x_2789);
-lean_ctor_set(x_2847, 1, x_2);
-lean_ctor_set(x_2847, 2, x_3);
-lean_ctor_set(x_2847, 3, x_4);
-lean_ctor_set_uint8(x_2847, sizeof(void*)*4, x_2798);
-return x_2847;
-}
-}
-else
-{
-lean_object* x_2848; lean_object* x_2849; lean_object* x_2850; lean_object* x_2851; lean_object* x_2852; lean_object* x_2853; lean_object* x_2854; 
-lean_dec(x_2789);
-x_2848 = lean_ctor_get(x_1, 0);
-lean_inc(x_2848);
-x_2849 = lean_ctor_get(x_1, 1);
-lean_inc(x_2849);
-x_2850 = lean_ctor_get(x_1, 2);
-lean_inc(x_2850);
-x_2851 = lean_ctor_get(x_1, 3);
-lean_inc(x_2851);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2852 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2852 = lean_box(0);
-}
-x_2853 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2853, 0, x_2848);
-lean_ctor_set(x_2853, 1, x_2849);
-lean_ctor_set(x_2853, 2, x_2850);
-lean_ctor_set(x_2853, 3, x_2851);
-lean_ctor_set_uint8(x_2853, sizeof(void*)*4, x_2798);
-if (lean_is_scalar(x_2852)) {
- x_2854 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2854 = x_2852;
-}
-lean_ctor_set(x_2854, 0, x_2853);
-lean_ctor_set(x_2854, 1, x_2);
-lean_ctor_set(x_2854, 2, x_3);
-lean_ctor_set(x_2854, 3, x_4);
-lean_ctor_set_uint8(x_2854, sizeof(void*)*4, x_2798);
-return x_2854;
-}
-}
-}
-}
-else
-{
-uint8_t x_2855; 
-x_2855 = lean_ctor_get_uint8(x_2788, sizeof(void*)*4);
-if (x_2855 == 0)
-{
-lean_object* x_2856; 
-x_2856 = lean_ctor_get(x_4, 3);
-lean_inc(x_2856);
-if (lean_obj_tag(x_2856) == 0)
-{
-uint8_t x_2857; 
-x_2857 = !lean_is_exclusive(x_4);
-if (x_2857 == 0)
-{
-lean_object* x_2858; lean_object* x_2859; uint8_t x_2860; 
-x_2858 = lean_ctor_get(x_4, 3);
-lean_dec(x_2858);
-x_2859 = lean_ctor_get(x_4, 0);
-lean_dec(x_2859);
-x_2860 = !lean_is_exclusive(x_2788);
-if (x_2860 == 0)
-{
-lean_object* x_2861; lean_object* x_2862; lean_object* x_2863; lean_object* x_2864; uint8_t x_2865; 
-x_2861 = lean_ctor_get(x_2788, 0);
-x_2862 = lean_ctor_get(x_2788, 1);
-x_2863 = lean_ctor_get(x_2788, 2);
-x_2864 = lean_ctor_get(x_2788, 3);
-lean_inc(x_1);
-lean_ctor_set(x_2788, 3, x_2861);
-lean_ctor_set(x_2788, 2, x_3);
-lean_ctor_set(x_2788, 1, x_2);
-lean_ctor_set(x_2788, 0, x_1);
-x_2865 = !lean_is_exclusive(x_1);
-if (x_2865 == 0)
-{
-lean_object* x_2866; lean_object* x_2867; lean_object* x_2868; lean_object* x_2869; 
-x_2866 = lean_ctor_get(x_1, 3);
-lean_dec(x_2866);
-x_2867 = lean_ctor_get(x_1, 2);
-lean_dec(x_2867);
-x_2868 = lean_ctor_get(x_1, 1);
-lean_dec(x_2868);
-x_2869 = lean_ctor_get(x_1, 0);
-lean_dec(x_2869);
-lean_ctor_set_uint8(x_2788, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 0, x_2864);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_2863);
-lean_ctor_set(x_1, 1, x_2862);
-lean_ctor_set(x_1, 0, x_2788);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2855);
-return x_1;
-}
-else
-{
-lean_object* x_2870; 
-lean_dec(x_1);
-lean_ctor_set_uint8(x_2788, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 0, x_2864);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-x_2870 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2870, 0, x_2788);
-lean_ctor_set(x_2870, 1, x_2862);
-lean_ctor_set(x_2870, 2, x_2863);
-lean_ctor_set(x_2870, 3, x_4);
-lean_ctor_set_uint8(x_2870, sizeof(void*)*4, x_2855);
-return x_2870;
-}
-}
-else
-{
-lean_object* x_2871; lean_object* x_2872; lean_object* x_2873; lean_object* x_2874; lean_object* x_2875; lean_object* x_2876; lean_object* x_2877; 
-x_2871 = lean_ctor_get(x_2788, 0);
-x_2872 = lean_ctor_get(x_2788, 1);
-x_2873 = lean_ctor_get(x_2788, 2);
-x_2874 = lean_ctor_get(x_2788, 3);
-lean_inc(x_2874);
-lean_inc(x_2873);
-lean_inc(x_2872);
-lean_inc(x_2871);
-lean_dec(x_2788);
-lean_inc(x_1);
-x_2875 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2875, 0, x_1);
-lean_ctor_set(x_2875, 1, x_2);
-lean_ctor_set(x_2875, 2, x_3);
-lean_ctor_set(x_2875, 3, x_2871);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2876 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2876 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2875, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 0, x_2874);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-if (lean_is_scalar(x_2876)) {
- x_2877 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2877 = x_2876;
-}
-lean_ctor_set(x_2877, 0, x_2875);
-lean_ctor_set(x_2877, 1, x_2872);
-lean_ctor_set(x_2877, 2, x_2873);
-lean_ctor_set(x_2877, 3, x_4);
-lean_ctor_set_uint8(x_2877, sizeof(void*)*4, x_2855);
-return x_2877;
-}
-}
-else
-{
-lean_object* x_2878; lean_object* x_2879; lean_object* x_2880; lean_object* x_2881; lean_object* x_2882; lean_object* x_2883; lean_object* x_2884; lean_object* x_2885; lean_object* x_2886; lean_object* x_2887; lean_object* x_2888; 
-x_2878 = lean_ctor_get(x_4, 1);
-x_2879 = lean_ctor_get(x_4, 2);
-lean_inc(x_2879);
-lean_inc(x_2878);
-lean_dec(x_4);
-x_2880 = lean_ctor_get(x_2788, 0);
-lean_inc(x_2880);
-x_2881 = lean_ctor_get(x_2788, 1);
-lean_inc(x_2881);
-x_2882 = lean_ctor_get(x_2788, 2);
-lean_inc(x_2882);
-x_2883 = lean_ctor_get(x_2788, 3);
-lean_inc(x_2883);
-if (lean_is_exclusive(x_2788)) {
- lean_ctor_release(x_2788, 0);
- lean_ctor_release(x_2788, 1);
- lean_ctor_release(x_2788, 2);
- lean_ctor_release(x_2788, 3);
- x_2884 = x_2788;
-} else {
- lean_dec_ref(x_2788);
- x_2884 = lean_box(0);
-}
-lean_inc(x_1);
-if (lean_is_scalar(x_2884)) {
- x_2885 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2885 = x_2884;
-}
-lean_ctor_set(x_2885, 0, x_1);
-lean_ctor_set(x_2885, 1, x_2);
-lean_ctor_set(x_2885, 2, x_3);
-lean_ctor_set(x_2885, 3, x_2880);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2886 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2886 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2885, sizeof(void*)*4, x_233);
-x_2887 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2887, 0, x_2883);
-lean_ctor_set(x_2887, 1, x_2878);
-lean_ctor_set(x_2887, 2, x_2879);
-lean_ctor_set(x_2887, 3, x_2856);
-lean_ctor_set_uint8(x_2887, sizeof(void*)*4, x_233);
-if (lean_is_scalar(x_2886)) {
- x_2888 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2888 = x_2886;
-}
-lean_ctor_set(x_2888, 0, x_2885);
-lean_ctor_set(x_2888, 1, x_2881);
-lean_ctor_set(x_2888, 2, x_2882);
-lean_ctor_set(x_2888, 3, x_2887);
-lean_ctor_set_uint8(x_2888, sizeof(void*)*4, x_2855);
-return x_2888;
-}
+x_2036 = 1;
+lean_ctor_set(x_1982, 3, x_4);
+lean_ctor_set(x_1982, 2, x_3);
+lean_ctor_set(x_1982, 1, x_2);
+lean_ctor_set(x_1982, 0, x_1);
+lean_ctor_set_uint8(x_1982, sizeof(void*)*4, x_2036);
+return x_1982;
 }
 else
 {
-uint8_t x_2889; 
-x_2889 = lean_ctor_get_uint8(x_2856, sizeof(void*)*4);
-if (x_2889 == 0)
-{
-uint8_t x_2890; 
-x_2890 = !lean_is_exclusive(x_4);
-if (x_2890 == 0)
-{
-lean_object* x_2891; lean_object* x_2892; lean_object* x_2893; lean_object* x_2894; uint8_t x_2895; 
-x_2891 = lean_ctor_get(x_4, 1);
-x_2892 = lean_ctor_get(x_4, 2);
-x_2893 = lean_ctor_get(x_4, 3);
-lean_dec(x_2893);
-x_2894 = lean_ctor_get(x_4, 0);
-lean_dec(x_2894);
-x_2895 = !lean_is_exclusive(x_2788);
-if (x_2895 == 0)
-{
-uint8_t x_2896; 
-x_2896 = !lean_is_exclusive(x_2856);
-if (x_2896 == 0)
-{
-lean_object* x_2897; lean_object* x_2898; lean_object* x_2899; lean_object* x_2900; lean_object* x_2901; lean_object* x_2902; lean_object* x_2903; lean_object* x_2904; uint8_t x_2905; 
-x_2897 = lean_ctor_get(x_2788, 0);
-x_2898 = lean_ctor_get(x_2788, 1);
-x_2899 = lean_ctor_get(x_2788, 2);
-x_2900 = lean_ctor_get(x_2788, 3);
-x_2901 = lean_ctor_get(x_2856, 0);
-x_2902 = lean_ctor_get(x_2856, 1);
-x_2903 = lean_ctor_get(x_2856, 2);
-x_2904 = lean_ctor_get(x_2856, 3);
-lean_ctor_set(x_2856, 3, x_2900);
-lean_ctor_set(x_2856, 2, x_2899);
-lean_ctor_set(x_2856, 1, x_2898);
-lean_ctor_set(x_2856, 0, x_2897);
-lean_inc(x_1);
-lean_ctor_set(x_2788, 3, x_2856);
-lean_ctor_set(x_2788, 2, x_3);
-lean_ctor_set(x_2788, 1, x_2);
-lean_ctor_set(x_2788, 0, x_1);
-x_2905 = !lean_is_exclusive(x_1);
-if (x_2905 == 0)
-{
-lean_object* x_2906; lean_object* x_2907; lean_object* x_2908; lean_object* x_2909; 
-x_2906 = lean_ctor_get(x_1, 3);
-lean_dec(x_2906);
-x_2907 = lean_ctor_get(x_1, 2);
-lean_dec(x_2907);
-x_2908 = lean_ctor_get(x_1, 1);
-lean_dec(x_2908);
-x_2909 = lean_ctor_get(x_1, 0);
-lean_dec(x_2909);
-lean_ctor_set_uint8(x_2788, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 3, x_2904);
-lean_ctor_set(x_4, 2, x_2903);
-lean_ctor_set(x_4, 1, x_2902);
-lean_ctor_set(x_4, 0, x_2901);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_2892);
-lean_ctor_set(x_1, 1, x_2891);
-lean_ctor_set(x_1, 0, x_2788);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2889);
-return x_1;
-}
-else
-{
-lean_object* x_2910; 
-lean_dec(x_1);
-lean_ctor_set_uint8(x_2788, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 3, x_2904);
-lean_ctor_set(x_4, 2, x_2903);
-lean_ctor_set(x_4, 1, x_2902);
-lean_ctor_set(x_4, 0, x_2901);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-x_2910 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2910, 0, x_2788);
-lean_ctor_set(x_2910, 1, x_2891);
-lean_ctor_set(x_2910, 2, x_2892);
-lean_ctor_set(x_2910, 3, x_4);
-lean_ctor_set_uint8(x_2910, sizeof(void*)*4, x_2889);
-return x_2910;
-}
-}
-else
-{
-lean_object* x_2911; lean_object* x_2912; lean_object* x_2913; lean_object* x_2914; lean_object* x_2915; lean_object* x_2916; lean_object* x_2917; lean_object* x_2918; lean_object* x_2919; lean_object* x_2920; lean_object* x_2921; 
-x_2911 = lean_ctor_get(x_2788, 0);
-x_2912 = lean_ctor_get(x_2788, 1);
-x_2913 = lean_ctor_get(x_2788, 2);
-x_2914 = lean_ctor_get(x_2788, 3);
-x_2915 = lean_ctor_get(x_2856, 0);
-x_2916 = lean_ctor_get(x_2856, 1);
-x_2917 = lean_ctor_get(x_2856, 2);
-x_2918 = lean_ctor_get(x_2856, 3);
-lean_inc(x_2918);
-lean_inc(x_2917);
-lean_inc(x_2916);
-lean_inc(x_2915);
-lean_dec(x_2856);
-x_2919 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2919, 0, x_2911);
-lean_ctor_set(x_2919, 1, x_2912);
-lean_ctor_set(x_2919, 2, x_2913);
-lean_ctor_set(x_2919, 3, x_2914);
-lean_ctor_set_uint8(x_2919, sizeof(void*)*4, x_2889);
-lean_inc(x_1);
-lean_ctor_set(x_2788, 3, x_2919);
-lean_ctor_set(x_2788, 2, x_3);
-lean_ctor_set(x_2788, 1, x_2);
-lean_ctor_set(x_2788, 0, x_1);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2920 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2920 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2788, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 3, x_2918);
-lean_ctor_set(x_4, 2, x_2917);
-lean_ctor_set(x_4, 1, x_2916);
-lean_ctor_set(x_4, 0, x_2915);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-if (lean_is_scalar(x_2920)) {
- x_2921 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2921 = x_2920;
-}
-lean_ctor_set(x_2921, 0, x_2788);
-lean_ctor_set(x_2921, 1, x_2891);
-lean_ctor_set(x_2921, 2, x_2892);
-lean_ctor_set(x_2921, 3, x_4);
-lean_ctor_set_uint8(x_2921, sizeof(void*)*4, x_2889);
-return x_2921;
-}
-}
-else
-{
-lean_object* x_2922; lean_object* x_2923; lean_object* x_2924; lean_object* x_2925; lean_object* x_2926; lean_object* x_2927; lean_object* x_2928; lean_object* x_2929; lean_object* x_2930; lean_object* x_2931; lean_object* x_2932; lean_object* x_2933; lean_object* x_2934; 
-x_2922 = lean_ctor_get(x_2788, 0);
-x_2923 = lean_ctor_get(x_2788, 1);
-x_2924 = lean_ctor_get(x_2788, 2);
-x_2925 = lean_ctor_get(x_2788, 3);
-lean_inc(x_2925);
-lean_inc(x_2924);
-lean_inc(x_2923);
-lean_inc(x_2922);
-lean_dec(x_2788);
-x_2926 = lean_ctor_get(x_2856, 0);
-lean_inc(x_2926);
-x_2927 = lean_ctor_get(x_2856, 1);
-lean_inc(x_2927);
-x_2928 = lean_ctor_get(x_2856, 2);
-lean_inc(x_2928);
-x_2929 = lean_ctor_get(x_2856, 3);
-lean_inc(x_2929);
-if (lean_is_exclusive(x_2856)) {
- lean_ctor_release(x_2856, 0);
- lean_ctor_release(x_2856, 1);
- lean_ctor_release(x_2856, 2);
- lean_ctor_release(x_2856, 3);
- x_2930 = x_2856;
-} else {
- lean_dec_ref(x_2856);
- x_2930 = lean_box(0);
-}
-if (lean_is_scalar(x_2930)) {
- x_2931 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2931 = x_2930;
-}
-lean_ctor_set(x_2931, 0, x_2922);
-lean_ctor_set(x_2931, 1, x_2923);
-lean_ctor_set(x_2931, 2, x_2924);
-lean_ctor_set(x_2931, 3, x_2925);
-lean_ctor_set_uint8(x_2931, sizeof(void*)*4, x_2889);
-lean_inc(x_1);
-x_2932 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2932, 0, x_1);
-lean_ctor_set(x_2932, 1, x_2);
-lean_ctor_set(x_2932, 2, x_3);
-lean_ctor_set(x_2932, 3, x_2931);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2933 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2933 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2932, sizeof(void*)*4, x_233);
-lean_ctor_set(x_4, 3, x_2929);
-lean_ctor_set(x_4, 2, x_2928);
-lean_ctor_set(x_4, 1, x_2927);
-lean_ctor_set(x_4, 0, x_2926);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_233);
-if (lean_is_scalar(x_2933)) {
- x_2934 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2934 = x_2933;
-}
-lean_ctor_set(x_2934, 0, x_2932);
-lean_ctor_set(x_2934, 1, x_2891);
-lean_ctor_set(x_2934, 2, x_2892);
-lean_ctor_set(x_2934, 3, x_4);
-lean_ctor_set_uint8(x_2934, sizeof(void*)*4, x_2889);
-return x_2934;
-}
-}
-else
-{
-lean_object* x_2935; lean_object* x_2936; lean_object* x_2937; lean_object* x_2938; lean_object* x_2939; lean_object* x_2940; lean_object* x_2941; lean_object* x_2942; lean_object* x_2943; lean_object* x_2944; lean_object* x_2945; lean_object* x_2946; lean_object* x_2947; lean_object* x_2948; lean_object* x_2949; lean_object* x_2950; lean_object* x_2951; 
-x_2935 = lean_ctor_get(x_4, 1);
-x_2936 = lean_ctor_get(x_4, 2);
-lean_inc(x_2936);
-lean_inc(x_2935);
-lean_dec(x_4);
-x_2937 = lean_ctor_get(x_2788, 0);
-lean_inc(x_2937);
-x_2938 = lean_ctor_get(x_2788, 1);
-lean_inc(x_2938);
-x_2939 = lean_ctor_get(x_2788, 2);
-lean_inc(x_2939);
-x_2940 = lean_ctor_get(x_2788, 3);
-lean_inc(x_2940);
-if (lean_is_exclusive(x_2788)) {
- lean_ctor_release(x_2788, 0);
- lean_ctor_release(x_2788, 1);
- lean_ctor_release(x_2788, 2);
- lean_ctor_release(x_2788, 3);
- x_2941 = x_2788;
-} else {
- lean_dec_ref(x_2788);
- x_2941 = lean_box(0);
-}
-x_2942 = lean_ctor_get(x_2856, 0);
-lean_inc(x_2942);
-x_2943 = lean_ctor_get(x_2856, 1);
-lean_inc(x_2943);
-x_2944 = lean_ctor_get(x_2856, 2);
-lean_inc(x_2944);
-x_2945 = lean_ctor_get(x_2856, 3);
-lean_inc(x_2945);
-if (lean_is_exclusive(x_2856)) {
- lean_ctor_release(x_2856, 0);
- lean_ctor_release(x_2856, 1);
- lean_ctor_release(x_2856, 2);
- lean_ctor_release(x_2856, 3);
- x_2946 = x_2856;
-} else {
- lean_dec_ref(x_2856);
- x_2946 = lean_box(0);
-}
-if (lean_is_scalar(x_2946)) {
- x_2947 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2947 = x_2946;
-}
-lean_ctor_set(x_2947, 0, x_2937);
-lean_ctor_set(x_2947, 1, x_2938);
-lean_ctor_set(x_2947, 2, x_2939);
-lean_ctor_set(x_2947, 3, x_2940);
-lean_ctor_set_uint8(x_2947, sizeof(void*)*4, x_2889);
-lean_inc(x_1);
-if (lean_is_scalar(x_2941)) {
- x_2948 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2948 = x_2941;
-}
-lean_ctor_set(x_2948, 0, x_1);
-lean_ctor_set(x_2948, 1, x_2);
-lean_ctor_set(x_2948, 2, x_3);
-lean_ctor_set(x_2948, 3, x_2947);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_2949 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_2949 = lean_box(0);
-}
-lean_ctor_set_uint8(x_2948, sizeof(void*)*4, x_233);
-x_2950 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2950, 0, x_2942);
-lean_ctor_set(x_2950, 1, x_2943);
-lean_ctor_set(x_2950, 2, x_2944);
-lean_ctor_set(x_2950, 3, x_2945);
-lean_ctor_set_uint8(x_2950, sizeof(void*)*4, x_233);
-if (lean_is_scalar(x_2949)) {
- x_2951 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2951 = x_2949;
-}
-lean_ctor_set(x_2951, 0, x_2948);
-lean_ctor_set(x_2951, 1, x_2935);
-lean_ctor_set(x_2951, 2, x_2936);
-lean_ctor_set(x_2951, 3, x_2950);
-lean_ctor_set_uint8(x_2951, sizeof(void*)*4, x_2889);
-return x_2951;
-}
-}
-else
-{
-uint8_t x_2952; 
-x_2952 = !lean_is_exclusive(x_1);
-if (x_2952 == 0)
-{
-uint8_t x_2953; 
-x_2953 = !lean_is_exclusive(x_4);
-if (x_2953 == 0)
-{
-lean_object* x_2954; lean_object* x_2955; lean_object* x_2956; lean_object* x_2957; lean_object* x_2958; lean_object* x_2959; lean_object* x_2960; lean_object* x_2961; uint8_t x_2962; 
-x_2954 = lean_ctor_get(x_1, 0);
-x_2955 = lean_ctor_get(x_1, 1);
-x_2956 = lean_ctor_get(x_1, 2);
-x_2957 = lean_ctor_get(x_1, 3);
-x_2958 = lean_ctor_get(x_4, 1);
-x_2959 = lean_ctor_get(x_4, 2);
-x_2960 = lean_ctor_get(x_4, 3);
-lean_dec(x_2960);
-x_2961 = lean_ctor_get(x_4, 0);
-lean_dec(x_2961);
-x_2962 = !lean_is_exclusive(x_2788);
-if (x_2962 == 0)
-{
-lean_object* x_2963; lean_object* x_2964; lean_object* x_2965; lean_object* x_2966; lean_object* x_2967; 
-x_2963 = lean_ctor_get(x_2788, 0);
-x_2964 = lean_ctor_get(x_2788, 1);
-x_2965 = lean_ctor_get(x_2788, 2);
-x_2966 = lean_ctor_get(x_2788, 3);
-lean_ctor_set(x_2788, 3, x_2957);
-lean_ctor_set(x_2788, 2, x_2956);
-lean_ctor_set(x_2788, 1, x_2955);
-lean_ctor_set(x_2788, 0, x_2954);
-lean_ctor_set_uint8(x_2788, sizeof(void*)*4, x_2889);
-lean_ctor_set(x_4, 3, x_2963);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2889);
-lean_ctor_set(x_1, 3, x_2856);
-lean_ctor_set(x_1, 2, x_2959);
-lean_ctor_set(x_1, 1, x_2958);
-lean_ctor_set(x_1, 0, x_2966);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2889);
-x_2967 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2967, 0, x_4);
-lean_ctor_set(x_2967, 1, x_2964);
-lean_ctor_set(x_2967, 2, x_2965);
-lean_ctor_set(x_2967, 3, x_1);
-lean_ctor_set_uint8(x_2967, sizeof(void*)*4, x_2855);
-return x_2967;
-}
-else
-{
-lean_object* x_2968; lean_object* x_2969; lean_object* x_2970; lean_object* x_2971; lean_object* x_2972; lean_object* x_2973; 
-x_2968 = lean_ctor_get(x_2788, 0);
-x_2969 = lean_ctor_get(x_2788, 1);
-x_2970 = lean_ctor_get(x_2788, 2);
-x_2971 = lean_ctor_get(x_2788, 3);
-lean_inc(x_2971);
-lean_inc(x_2970);
-lean_inc(x_2969);
-lean_inc(x_2968);
-lean_dec(x_2788);
-x_2972 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2972, 0, x_2954);
-lean_ctor_set(x_2972, 1, x_2955);
-lean_ctor_set(x_2972, 2, x_2956);
-lean_ctor_set(x_2972, 3, x_2957);
-lean_ctor_set_uint8(x_2972, sizeof(void*)*4, x_2889);
-lean_ctor_set(x_4, 3, x_2968);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_2972);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2889);
-lean_ctor_set(x_1, 3, x_2856);
-lean_ctor_set(x_1, 2, x_2959);
-lean_ctor_set(x_1, 1, x_2958);
-lean_ctor_set(x_1, 0, x_2971);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2889);
-x_2973 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2973, 0, x_4);
-lean_ctor_set(x_2973, 1, x_2969);
-lean_ctor_set(x_2973, 2, x_2970);
-lean_ctor_set(x_2973, 3, x_1);
-lean_ctor_set_uint8(x_2973, sizeof(void*)*4, x_2855);
-return x_2973;
-}
-}
-else
-{
-lean_object* x_2974; lean_object* x_2975; lean_object* x_2976; lean_object* x_2977; lean_object* x_2978; lean_object* x_2979; lean_object* x_2980; lean_object* x_2981; lean_object* x_2982; lean_object* x_2983; lean_object* x_2984; lean_object* x_2985; lean_object* x_2986; lean_object* x_2987; 
-x_2974 = lean_ctor_get(x_1, 0);
-x_2975 = lean_ctor_get(x_1, 1);
-x_2976 = lean_ctor_get(x_1, 2);
-x_2977 = lean_ctor_get(x_1, 3);
-x_2978 = lean_ctor_get(x_4, 1);
-x_2979 = lean_ctor_get(x_4, 2);
-lean_inc(x_2979);
-lean_inc(x_2978);
-lean_dec(x_4);
-x_2980 = lean_ctor_get(x_2788, 0);
-lean_inc(x_2980);
-x_2981 = lean_ctor_get(x_2788, 1);
-lean_inc(x_2981);
-x_2982 = lean_ctor_get(x_2788, 2);
-lean_inc(x_2982);
-x_2983 = lean_ctor_get(x_2788, 3);
-lean_inc(x_2983);
-if (lean_is_exclusive(x_2788)) {
- lean_ctor_release(x_2788, 0);
- lean_ctor_release(x_2788, 1);
- lean_ctor_release(x_2788, 2);
- lean_ctor_release(x_2788, 3);
- x_2984 = x_2788;
-} else {
- lean_dec_ref(x_2788);
- x_2984 = lean_box(0);
-}
-if (lean_is_scalar(x_2984)) {
- x_2985 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_2985 = x_2984;
-}
-lean_ctor_set(x_2985, 0, x_2974);
-lean_ctor_set(x_2985, 1, x_2975);
-lean_ctor_set(x_2985, 2, x_2976);
-lean_ctor_set(x_2985, 3, x_2977);
-lean_ctor_set_uint8(x_2985, sizeof(void*)*4, x_2889);
-x_2986 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2986, 0, x_2985);
-lean_ctor_set(x_2986, 1, x_2);
-lean_ctor_set(x_2986, 2, x_3);
-lean_ctor_set(x_2986, 3, x_2980);
-lean_ctor_set_uint8(x_2986, sizeof(void*)*4, x_2889);
-lean_ctor_set(x_1, 3, x_2856);
-lean_ctor_set(x_1, 2, x_2979);
-lean_ctor_set(x_1, 1, x_2978);
-lean_ctor_set(x_1, 0, x_2983);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2889);
-x_2987 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_2987, 0, x_2986);
-lean_ctor_set(x_2987, 1, x_2981);
-lean_ctor_set(x_2987, 2, x_2982);
-lean_ctor_set(x_2987, 3, x_1);
-lean_ctor_set_uint8(x_2987, sizeof(void*)*4, x_2855);
-return x_2987;
-}
-}
-else
-{
-lean_object* x_2988; lean_object* x_2989; lean_object* x_2990; lean_object* x_2991; lean_object* x_2992; lean_object* x_2993; lean_object* x_2994; lean_object* x_2995; lean_object* x_2996; lean_object* x_2997; lean_object* x_2998; lean_object* x_2999; lean_object* x_3000; lean_object* x_3001; lean_object* x_3002; lean_object* x_3003; 
-x_2988 = lean_ctor_get(x_1, 0);
-x_2989 = lean_ctor_get(x_1, 1);
-x_2990 = lean_ctor_get(x_1, 2);
-x_2991 = lean_ctor_get(x_1, 3);
-lean_inc(x_2991);
-lean_inc(x_2990);
-lean_inc(x_2989);
-lean_inc(x_2988);
-lean_dec(x_1);
-x_2992 = lean_ctor_get(x_4, 1);
-lean_inc(x_2992);
-x_2993 = lean_ctor_get(x_4, 2);
-lean_inc(x_2993);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_2994 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_2994 = lean_box(0);
-}
-x_2995 = lean_ctor_get(x_2788, 0);
-lean_inc(x_2995);
-x_2996 = lean_ctor_get(x_2788, 1);
-lean_inc(x_2996);
-x_2997 = lean_ctor_get(x_2788, 2);
-lean_inc(x_2997);
-x_2998 = lean_ctor_get(x_2788, 3);
-lean_inc(x_2998);
-if (lean_is_exclusive(x_2788)) {
- lean_ctor_release(x_2788, 0);
- lean_ctor_release(x_2788, 1);
- lean_ctor_release(x_2788, 2);
- lean_ctor_release(x_2788, 3);
- x_2999 = x_2788;
-} else {
- lean_dec_ref(x_2788);
- x_2999 = lean_box(0);
-}
-if (lean_is_scalar(x_2999)) {
- x_3000 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3000 = x_2999;
-}
-lean_ctor_set(x_3000, 0, x_2988);
-lean_ctor_set(x_3000, 1, x_2989);
-lean_ctor_set(x_3000, 2, x_2990);
-lean_ctor_set(x_3000, 3, x_2991);
-lean_ctor_set_uint8(x_3000, sizeof(void*)*4, x_2889);
-if (lean_is_scalar(x_2994)) {
- x_3001 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3001 = x_2994;
-}
-lean_ctor_set(x_3001, 0, x_3000);
-lean_ctor_set(x_3001, 1, x_2);
-lean_ctor_set(x_3001, 2, x_3);
-lean_ctor_set(x_3001, 3, x_2995);
-lean_ctor_set_uint8(x_3001, sizeof(void*)*4, x_2889);
-x_3002 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3002, 0, x_2998);
-lean_ctor_set(x_3002, 1, x_2992);
-lean_ctor_set(x_3002, 2, x_2993);
-lean_ctor_set(x_3002, 3, x_2856);
-lean_ctor_set_uint8(x_3002, sizeof(void*)*4, x_2889);
-x_3003 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3003, 0, x_3001);
-lean_ctor_set(x_3003, 1, x_2996);
-lean_ctor_set(x_3003, 2, x_2997);
-lean_ctor_set(x_3003, 3, x_3002);
-lean_ctor_set_uint8(x_3003, sizeof(void*)*4, x_2855);
-return x_3003;
-}
-}
-}
-}
-else
-{
-lean_object* x_3004; 
-x_3004 = lean_ctor_get(x_4, 3);
-lean_inc(x_3004);
-if (lean_obj_tag(x_3004) == 0)
-{
-uint8_t x_3005; 
-x_3005 = !lean_is_exclusive(x_2788);
-if (x_3005 == 0)
-{
-lean_object* x_3006; lean_object* x_3007; lean_object* x_3008; lean_object* x_3009; uint8_t x_3010; 
-x_3006 = lean_ctor_get(x_2788, 3);
-lean_dec(x_3006);
-x_3007 = lean_ctor_get(x_2788, 2);
-lean_dec(x_3007);
-x_3008 = lean_ctor_get(x_2788, 1);
-lean_dec(x_3008);
-x_3009 = lean_ctor_get(x_2788, 0);
-lean_dec(x_3009);
-x_3010 = !lean_is_exclusive(x_1);
-if (x_3010 == 0)
-{
-lean_object* x_3011; lean_object* x_3012; lean_object* x_3013; lean_object* x_3014; 
-x_3011 = lean_ctor_get(x_1, 0);
-x_3012 = lean_ctor_get(x_1, 1);
-x_3013 = lean_ctor_get(x_1, 2);
-x_3014 = lean_ctor_get(x_1, 3);
-lean_ctor_set(x_2788, 3, x_3014);
-lean_ctor_set(x_2788, 2, x_3013);
-lean_ctor_set(x_2788, 1, x_3012);
-lean_ctor_set(x_2788, 0, x_3011);
-lean_ctor_set(x_1, 3, x_4);
-lean_ctor_set(x_1, 2, x_3);
-lean_ctor_set(x_1, 1, x_2);
-lean_ctor_set(x_1, 0, x_2788);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2855);
-return x_1;
-}
-else
-{
-lean_object* x_3015; lean_object* x_3016; lean_object* x_3017; lean_object* x_3018; lean_object* x_3019; 
-x_3015 = lean_ctor_get(x_1, 0);
-x_3016 = lean_ctor_get(x_1, 1);
-x_3017 = lean_ctor_get(x_1, 2);
-x_3018 = lean_ctor_get(x_1, 3);
-lean_inc(x_3018);
-lean_inc(x_3017);
-lean_inc(x_3016);
-lean_inc(x_3015);
-lean_dec(x_1);
-lean_ctor_set(x_2788, 3, x_3018);
-lean_ctor_set(x_2788, 2, x_3017);
-lean_ctor_set(x_2788, 1, x_3016);
-lean_ctor_set(x_2788, 0, x_3015);
-x_3019 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3019, 0, x_2788);
-lean_ctor_set(x_3019, 1, x_2);
-lean_ctor_set(x_3019, 2, x_3);
-lean_ctor_set(x_3019, 3, x_4);
-lean_ctor_set_uint8(x_3019, sizeof(void*)*4, x_2855);
-return x_3019;
-}
-}
-else
-{
-lean_object* x_3020; lean_object* x_3021; lean_object* x_3022; lean_object* x_3023; lean_object* x_3024; lean_object* x_3025; lean_object* x_3026; 
-lean_dec(x_2788);
-x_3020 = lean_ctor_get(x_1, 0);
-lean_inc(x_3020);
-x_3021 = lean_ctor_get(x_1, 1);
-lean_inc(x_3021);
-x_3022 = lean_ctor_get(x_1, 2);
-lean_inc(x_3022);
-x_3023 = lean_ctor_get(x_1, 3);
-lean_inc(x_3023);
-if (lean_is_exclusive(x_1)) {
- lean_ctor_release(x_1, 0);
- lean_ctor_release(x_1, 1);
- lean_ctor_release(x_1, 2);
- lean_ctor_release(x_1, 3);
- x_3024 = x_1;
-} else {
- lean_dec_ref(x_1);
- x_3024 = lean_box(0);
-}
-x_3025 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3025, 0, x_3020);
-lean_ctor_set(x_3025, 1, x_3021);
-lean_ctor_set(x_3025, 2, x_3022);
-lean_ctor_set(x_3025, 3, x_3023);
-lean_ctor_set_uint8(x_3025, sizeof(void*)*4, x_2855);
-if (lean_is_scalar(x_3024)) {
- x_3026 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3026 = x_3024;
-}
-lean_ctor_set(x_3026, 0, x_3025);
-lean_ctor_set(x_3026, 1, x_2);
-lean_ctor_set(x_3026, 2, x_3);
-lean_ctor_set(x_3026, 3, x_4);
-lean_ctor_set_uint8(x_3026, sizeof(void*)*4, x_2855);
-return x_3026;
-}
-}
-else
-{
-uint8_t x_3027; 
-x_3027 = lean_ctor_get_uint8(x_3004, sizeof(void*)*4);
-if (x_3027 == 0)
-{
-uint8_t x_3028; 
-x_3028 = !lean_is_exclusive(x_1);
-if (x_3028 == 0)
-{
-uint8_t x_3029; 
-x_3029 = !lean_is_exclusive(x_4);
-if (x_3029 == 0)
-{
-lean_object* x_3030; lean_object* x_3031; lean_object* x_3032; lean_object* x_3033; lean_object* x_3034; lean_object* x_3035; lean_object* x_3036; lean_object* x_3037; uint8_t x_3038; 
-x_3030 = lean_ctor_get(x_1, 0);
-x_3031 = lean_ctor_get(x_1, 1);
-x_3032 = lean_ctor_get(x_1, 2);
-x_3033 = lean_ctor_get(x_1, 3);
-x_3034 = lean_ctor_get(x_4, 1);
-x_3035 = lean_ctor_get(x_4, 2);
-x_3036 = lean_ctor_get(x_4, 3);
-lean_dec(x_3036);
-x_3037 = lean_ctor_get(x_4, 0);
-lean_dec(x_3037);
-x_3038 = !lean_is_exclusive(x_3004);
-if (x_3038 == 0)
-{
-lean_object* x_3039; lean_object* x_3040; lean_object* x_3041; lean_object* x_3042; lean_object* x_3043; 
-x_3039 = lean_ctor_get(x_3004, 0);
-x_3040 = lean_ctor_get(x_3004, 1);
-x_3041 = lean_ctor_get(x_3004, 2);
-x_3042 = lean_ctor_get(x_3004, 3);
-lean_ctor_set(x_3004, 3, x_3033);
-lean_ctor_set(x_3004, 2, x_3032);
-lean_ctor_set(x_3004, 1, x_3031);
-lean_ctor_set(x_3004, 0, x_3030);
-lean_ctor_set_uint8(x_3004, sizeof(void*)*4, x_2855);
-lean_ctor_set(x_4, 3, x_2788);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_3004);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2855);
-lean_ctor_set(x_1, 3, x_3042);
-lean_ctor_set(x_1, 2, x_3041);
-lean_ctor_set(x_1, 1, x_3040);
-lean_ctor_set(x_1, 0, x_3039);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2855);
-x_3043 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3043, 0, x_4);
-lean_ctor_set(x_3043, 1, x_3034);
-lean_ctor_set(x_3043, 2, x_3035);
-lean_ctor_set(x_3043, 3, x_1);
-lean_ctor_set_uint8(x_3043, sizeof(void*)*4, x_3027);
-return x_3043;
-}
-else
-{
-lean_object* x_3044; lean_object* x_3045; lean_object* x_3046; lean_object* x_3047; lean_object* x_3048; lean_object* x_3049; 
-x_3044 = lean_ctor_get(x_3004, 0);
-x_3045 = lean_ctor_get(x_3004, 1);
-x_3046 = lean_ctor_get(x_3004, 2);
-x_3047 = lean_ctor_get(x_3004, 3);
-lean_inc(x_3047);
-lean_inc(x_3046);
-lean_inc(x_3045);
-lean_inc(x_3044);
-lean_dec(x_3004);
-x_3048 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3048, 0, x_3030);
-lean_ctor_set(x_3048, 1, x_3031);
-lean_ctor_set(x_3048, 2, x_3032);
-lean_ctor_set(x_3048, 3, x_3033);
-lean_ctor_set_uint8(x_3048, sizeof(void*)*4, x_2855);
-lean_ctor_set(x_4, 3, x_2788);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_3048);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_2855);
-lean_ctor_set(x_1, 3, x_3047);
-lean_ctor_set(x_1, 2, x_3046);
-lean_ctor_set(x_1, 1, x_3045);
-lean_ctor_set(x_1, 0, x_3044);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2855);
-x_3049 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3049, 0, x_4);
-lean_ctor_set(x_3049, 1, x_3034);
-lean_ctor_set(x_3049, 2, x_3035);
-lean_ctor_set(x_3049, 3, x_1);
-lean_ctor_set_uint8(x_3049, sizeof(void*)*4, x_3027);
-return x_3049;
-}
-}
-else
-{
-lean_object* x_3050; lean_object* x_3051; lean_object* x_3052; lean_object* x_3053; lean_object* x_3054; lean_object* x_3055; lean_object* x_3056; lean_object* x_3057; lean_object* x_3058; lean_object* x_3059; lean_object* x_3060; lean_object* x_3061; lean_object* x_3062; lean_object* x_3063; 
-x_3050 = lean_ctor_get(x_1, 0);
-x_3051 = lean_ctor_get(x_1, 1);
-x_3052 = lean_ctor_get(x_1, 2);
-x_3053 = lean_ctor_get(x_1, 3);
-x_3054 = lean_ctor_get(x_4, 1);
-x_3055 = lean_ctor_get(x_4, 2);
-lean_inc(x_3055);
-lean_inc(x_3054);
-lean_dec(x_4);
-x_3056 = lean_ctor_get(x_3004, 0);
-lean_inc(x_3056);
-x_3057 = lean_ctor_get(x_3004, 1);
-lean_inc(x_3057);
-x_3058 = lean_ctor_get(x_3004, 2);
-lean_inc(x_3058);
-x_3059 = lean_ctor_get(x_3004, 3);
-lean_inc(x_3059);
-if (lean_is_exclusive(x_3004)) {
- lean_ctor_release(x_3004, 0);
- lean_ctor_release(x_3004, 1);
- lean_ctor_release(x_3004, 2);
- lean_ctor_release(x_3004, 3);
- x_3060 = x_3004;
-} else {
- lean_dec_ref(x_3004);
- x_3060 = lean_box(0);
-}
-if (lean_is_scalar(x_3060)) {
- x_3061 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3061 = x_3060;
-}
-lean_ctor_set(x_3061, 0, x_3050);
-lean_ctor_set(x_3061, 1, x_3051);
-lean_ctor_set(x_3061, 2, x_3052);
-lean_ctor_set(x_3061, 3, x_3053);
-lean_ctor_set_uint8(x_3061, sizeof(void*)*4, x_2855);
-x_3062 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3062, 0, x_3061);
-lean_ctor_set(x_3062, 1, x_2);
-lean_ctor_set(x_3062, 2, x_3);
-lean_ctor_set(x_3062, 3, x_2788);
-lean_ctor_set_uint8(x_3062, sizeof(void*)*4, x_2855);
-lean_ctor_set(x_1, 3, x_3059);
-lean_ctor_set(x_1, 2, x_3058);
-lean_ctor_set(x_1, 1, x_3057);
-lean_ctor_set(x_1, 0, x_3056);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2855);
-x_3063 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3063, 0, x_3062);
-lean_ctor_set(x_3063, 1, x_3054);
-lean_ctor_set(x_3063, 2, x_3055);
-lean_ctor_set(x_3063, 3, x_1);
-lean_ctor_set_uint8(x_3063, sizeof(void*)*4, x_3027);
-return x_3063;
-}
-}
-else
-{
-lean_object* x_3064; lean_object* x_3065; lean_object* x_3066; lean_object* x_3067; lean_object* x_3068; lean_object* x_3069; lean_object* x_3070; lean_object* x_3071; lean_object* x_3072; lean_object* x_3073; lean_object* x_3074; lean_object* x_3075; lean_object* x_3076; lean_object* x_3077; lean_object* x_3078; lean_object* x_3079; 
-x_3064 = lean_ctor_get(x_1, 0);
-x_3065 = lean_ctor_get(x_1, 1);
-x_3066 = lean_ctor_get(x_1, 2);
-x_3067 = lean_ctor_get(x_1, 3);
-lean_inc(x_3067);
-lean_inc(x_3066);
-lean_inc(x_3065);
-lean_inc(x_3064);
-lean_dec(x_1);
-x_3068 = lean_ctor_get(x_4, 1);
-lean_inc(x_3068);
-x_3069 = lean_ctor_get(x_4, 2);
-lean_inc(x_3069);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_3070 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_3070 = lean_box(0);
-}
-x_3071 = lean_ctor_get(x_3004, 0);
-lean_inc(x_3071);
-x_3072 = lean_ctor_get(x_3004, 1);
-lean_inc(x_3072);
-x_3073 = lean_ctor_get(x_3004, 2);
-lean_inc(x_3073);
-x_3074 = lean_ctor_get(x_3004, 3);
-lean_inc(x_3074);
-if (lean_is_exclusive(x_3004)) {
- lean_ctor_release(x_3004, 0);
- lean_ctor_release(x_3004, 1);
- lean_ctor_release(x_3004, 2);
- lean_ctor_release(x_3004, 3);
- x_3075 = x_3004;
-} else {
- lean_dec_ref(x_3004);
- x_3075 = lean_box(0);
+uint8_t x_2037; lean_object* x_2038; 
+lean_dec(x_1982);
+x_2037 = 1;
+x_2038 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_2038, 0, x_1);
+lean_ctor_set(x_2038, 1, x_2);
+lean_ctor_set(x_2038, 2, x_3);
+lean_ctor_set(x_2038, 3, x_4);
+lean_ctor_set_uint8(x_2038, sizeof(void*)*4, x_2037);
+return x_2038;
 }
-if (lean_is_scalar(x_3075)) {
- x_3076 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3076 = x_3075;
 }
-lean_ctor_set(x_3076, 0, x_3064);
-lean_ctor_set(x_3076, 1, x_3065);
-lean_ctor_set(x_3076, 2, x_3066);
-lean_ctor_set(x_3076, 3, x_3067);
-lean_ctor_set_uint8(x_3076, sizeof(void*)*4, x_2855);
-if (lean_is_scalar(x_3070)) {
- x_3077 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3077 = x_3070;
 }
-lean_ctor_set(x_3077, 0, x_3076);
-lean_ctor_set(x_3077, 1, x_2);
-lean_ctor_set(x_3077, 2, x_3);
-lean_ctor_set(x_3077, 3, x_2788);
-lean_ctor_set_uint8(x_3077, sizeof(void*)*4, x_2855);
-x_3078 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3078, 0, x_3071);
-lean_ctor_set(x_3078, 1, x_3072);
-lean_ctor_set(x_3078, 2, x_3073);
-lean_ctor_set(x_3078, 3, x_3074);
-lean_ctor_set_uint8(x_3078, sizeof(void*)*4, x_2855);
-x_3079 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3079, 0, x_3077);
-lean_ctor_set(x_3079, 1, x_3068);
-lean_ctor_set(x_3079, 2, x_3069);
-lean_ctor_set(x_3079, 3, x_3078);
-lean_ctor_set_uint8(x_3079, sizeof(void*)*4, x_3027);
-return x_3079;
-}
-}
-else
-{
-uint8_t x_3080; 
-x_3080 = !lean_is_exclusive(x_1);
-if (x_3080 == 0)
-{
-uint8_t x_3081; 
-x_3081 = !lean_is_exclusive(x_4);
-if (x_3081 == 0)
-{
-lean_object* x_3082; lean_object* x_3083; lean_object* x_3084; lean_object* x_3085; lean_object* x_3086; lean_object* x_3087; lean_object* x_3088; lean_object* x_3089; uint8_t x_3090; 
-x_3082 = lean_ctor_get(x_1, 0);
-x_3083 = lean_ctor_get(x_1, 1);
-x_3084 = lean_ctor_get(x_1, 2);
-x_3085 = lean_ctor_get(x_1, 3);
-x_3086 = lean_ctor_get(x_4, 1);
-x_3087 = lean_ctor_get(x_4, 2);
-x_3088 = lean_ctor_get(x_4, 3);
-lean_dec(x_3088);
-x_3089 = lean_ctor_get(x_4, 0);
-lean_dec(x_3089);
-x_3090 = !lean_is_exclusive(x_2788);
-if (x_3090 == 0)
-{
-lean_object* x_3091; lean_object* x_3092; lean_object* x_3093; lean_object* x_3094; lean_object* x_3095; 
-x_3091 = lean_ctor_get(x_2788, 0);
-x_3092 = lean_ctor_get(x_2788, 1);
-x_3093 = lean_ctor_get(x_2788, 2);
-x_3094 = lean_ctor_get(x_2788, 3);
-lean_ctor_set(x_2788, 3, x_3085);
-lean_ctor_set(x_2788, 2, x_3084);
-lean_ctor_set(x_2788, 1, x_3083);
-lean_ctor_set(x_2788, 0, x_3082);
-lean_ctor_set_uint8(x_2788, sizeof(void*)*4, x_3027);
-lean_ctor_set(x_4, 3, x_3094);
-lean_ctor_set(x_4, 2, x_3093);
-lean_ctor_set(x_4, 1, x_3092);
-lean_ctor_set(x_4, 0, x_3091);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_3027);
-lean_ctor_set(x_1, 3, x_3004);
-lean_ctor_set(x_1, 2, x_3087);
-lean_ctor_set(x_1, 1, x_3086);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2787);
-x_3095 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3095, 0, x_2788);
-lean_ctor_set(x_3095, 1, x_2);
-lean_ctor_set(x_3095, 2, x_3);
-lean_ctor_set(x_3095, 3, x_1);
-lean_ctor_set_uint8(x_3095, sizeof(void*)*4, x_3027);
-return x_3095;
-}
-else
-{
-lean_object* x_3096; lean_object* x_3097; lean_object* x_3098; lean_object* x_3099; lean_object* x_3100; lean_object* x_3101; 
-x_3096 = lean_ctor_get(x_2788, 0);
-x_3097 = lean_ctor_get(x_2788, 1);
-x_3098 = lean_ctor_get(x_2788, 2);
-x_3099 = lean_ctor_get(x_2788, 3);
-lean_inc(x_3099);
-lean_inc(x_3098);
-lean_inc(x_3097);
-lean_inc(x_3096);
-lean_dec(x_2788);
-x_3100 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3100, 0, x_3082);
-lean_ctor_set(x_3100, 1, x_3083);
-lean_ctor_set(x_3100, 2, x_3084);
-lean_ctor_set(x_3100, 3, x_3085);
-lean_ctor_set_uint8(x_3100, sizeof(void*)*4, x_3027);
-lean_ctor_set(x_4, 3, x_3099);
-lean_ctor_set(x_4, 2, x_3098);
-lean_ctor_set(x_4, 1, x_3097);
-lean_ctor_set(x_4, 0, x_3096);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_3027);
-lean_ctor_set(x_1, 3, x_3004);
-lean_ctor_set(x_1, 2, x_3087);
-lean_ctor_set(x_1, 1, x_3086);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2787);
-x_3101 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3101, 0, x_3100);
-lean_ctor_set(x_3101, 1, x_2);
-lean_ctor_set(x_3101, 2, x_3);
-lean_ctor_set(x_3101, 3, x_1);
-lean_ctor_set_uint8(x_3101, sizeof(void*)*4, x_3027);
-return x_3101;
-}
-}
-else
-{
-lean_object* x_3102; lean_object* x_3103; lean_object* x_3104; lean_object* x_3105; lean_object* x_3106; lean_object* x_3107; lean_object* x_3108; lean_object* x_3109; lean_object* x_3110; lean_object* x_3111; lean_object* x_3112; lean_object* x_3113; lean_object* x_3114; lean_object* x_3115; 
-x_3102 = lean_ctor_get(x_1, 0);
-x_3103 = lean_ctor_get(x_1, 1);
-x_3104 = lean_ctor_get(x_1, 2);
-x_3105 = lean_ctor_get(x_1, 3);
-x_3106 = lean_ctor_get(x_4, 1);
-x_3107 = lean_ctor_get(x_4, 2);
-lean_inc(x_3107);
-lean_inc(x_3106);
-lean_dec(x_4);
-x_3108 = lean_ctor_get(x_2788, 0);
-lean_inc(x_3108);
-x_3109 = lean_ctor_get(x_2788, 1);
-lean_inc(x_3109);
-x_3110 = lean_ctor_get(x_2788, 2);
-lean_inc(x_3110);
-x_3111 = lean_ctor_get(x_2788, 3);
-lean_inc(x_3111);
-if (lean_is_exclusive(x_2788)) {
- lean_ctor_release(x_2788, 0);
- lean_ctor_release(x_2788, 1);
- lean_ctor_release(x_2788, 2);
- lean_ctor_release(x_2788, 3);
- x_3112 = x_2788;
-} else {
- lean_dec_ref(x_2788);
- x_3112 = lean_box(0);
-}
-if (lean_is_scalar(x_3112)) {
- x_3113 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3113 = x_3112;
-}
-lean_ctor_set(x_3113, 0, x_3102);
-lean_ctor_set(x_3113, 1, x_3103);
-lean_ctor_set(x_3113, 2, x_3104);
-lean_ctor_set(x_3113, 3, x_3105);
-lean_ctor_set_uint8(x_3113, sizeof(void*)*4, x_3027);
-x_3114 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3114, 0, x_3108);
-lean_ctor_set(x_3114, 1, x_3109);
-lean_ctor_set(x_3114, 2, x_3110);
-lean_ctor_set(x_3114, 3, x_3111);
-lean_ctor_set_uint8(x_3114, sizeof(void*)*4, x_3027);
-lean_ctor_set(x_1, 3, x_3004);
-lean_ctor_set(x_1, 2, x_3107);
-lean_ctor_set(x_1, 1, x_3106);
-lean_ctor_set(x_1, 0, x_3114);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2787);
-x_3115 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3115, 0, x_3113);
-lean_ctor_set(x_3115, 1, x_2);
-lean_ctor_set(x_3115, 2, x_3);
-lean_ctor_set(x_3115, 3, x_1);
-lean_ctor_set_uint8(x_3115, sizeof(void*)*4, x_3027);
-return x_3115;
-}
-}
-else
-{
-lean_object* x_3116; lean_object* x_3117; lean_object* x_3118; lean_object* x_3119; lean_object* x_3120; lean_object* x_3121; lean_object* x_3122; lean_object* x_3123; lean_object* x_3124; lean_object* x_3125; lean_object* x_3126; lean_object* x_3127; lean_object* x_3128; lean_object* x_3129; lean_object* x_3130; lean_object* x_3131; 
-x_3116 = lean_ctor_get(x_1, 0);
-x_3117 = lean_ctor_get(x_1, 1);
-x_3118 = lean_ctor_get(x_1, 2);
-x_3119 = lean_ctor_get(x_1, 3);
-lean_inc(x_3119);
-lean_inc(x_3118);
-lean_inc(x_3117);
-lean_inc(x_3116);
-lean_dec(x_1);
-x_3120 = lean_ctor_get(x_4, 1);
-lean_inc(x_3120);
-x_3121 = lean_ctor_get(x_4, 2);
-lean_inc(x_3121);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_3122 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_3122 = lean_box(0);
-}
-x_3123 = lean_ctor_get(x_2788, 0);
-lean_inc(x_3123);
-x_3124 = lean_ctor_get(x_2788, 1);
-lean_inc(x_3124);
-x_3125 = lean_ctor_get(x_2788, 2);
-lean_inc(x_3125);
-x_3126 = lean_ctor_get(x_2788, 3);
-lean_inc(x_3126);
-if (lean_is_exclusive(x_2788)) {
- lean_ctor_release(x_2788, 0);
- lean_ctor_release(x_2788, 1);
- lean_ctor_release(x_2788, 2);
- lean_ctor_release(x_2788, 3);
- x_3127 = x_2788;
-} else {
- lean_dec_ref(x_2788);
- x_3127 = lean_box(0);
-}
-if (lean_is_scalar(x_3127)) {
- x_3128 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3128 = x_3127;
-}
-lean_ctor_set(x_3128, 0, x_3116);
-lean_ctor_set(x_3128, 1, x_3117);
-lean_ctor_set(x_3128, 2, x_3118);
-lean_ctor_set(x_3128, 3, x_3119);
-lean_ctor_set_uint8(x_3128, sizeof(void*)*4, x_3027);
-if (lean_is_scalar(x_3122)) {
- x_3129 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_3129 = x_3122;
-}
-lean_ctor_set(x_3129, 0, x_3123);
-lean_ctor_set(x_3129, 1, x_3124);
-lean_ctor_set(x_3129, 2, x_3125);
-lean_ctor_set(x_3129, 3, x_3126);
-lean_ctor_set_uint8(x_3129, sizeof(void*)*4, x_3027);
-x_3130 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3130, 0, x_3129);
-lean_ctor_set(x_3130, 1, x_3120);
-lean_ctor_set(x_3130, 2, x_3121);
-lean_ctor_set(x_3130, 3, x_3004);
-lean_ctor_set_uint8(x_3130, sizeof(void*)*4, x_2787);
-x_3131 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3131, 0, x_3128);
-lean_ctor_set(x_3131, 1, x_2);
-lean_ctor_set(x_3131, 2, x_3);
-lean_ctor_set(x_3131, 3, x_3130);
-lean_ctor_set_uint8(x_3131, sizeof(void*)*4, x_3027);
-return x_3131;
 }
 }
 }
-}
-}
-}
-else
-{
-uint8_t x_3132; 
-x_3132 = !lean_is_exclusive(x_1);
-if (x_3132 == 0)
-{
-lean_object* x_3133; 
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_2787);
-x_3133 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3133, 0, x_1);
-lean_ctor_set(x_3133, 1, x_2);
-lean_ctor_set(x_3133, 2, x_3);
-lean_ctor_set(x_3133, 3, x_4);
-lean_ctor_set_uint8(x_3133, sizeof(void*)*4, x_2787);
-return x_3133;
-}
 else
 {
-lean_object* x_3134; lean_object* x_3135; lean_object* x_3136; lean_object* x_3137; lean_object* x_3138; lean_object* x_3139; 
-x_3134 = lean_ctor_get(x_1, 0);
-x_3135 = lean_ctor_get(x_1, 1);
-x_3136 = lean_ctor_get(x_1, 2);
-x_3137 = lean_ctor_get(x_1, 3);
-lean_inc(x_3137);
-lean_inc(x_3136);
-lean_inc(x_3135);
-lean_inc(x_3134);
-lean_dec(x_1);
-x_3138 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3138, 0, x_3134);
-lean_ctor_set(x_3138, 1, x_3135);
-lean_ctor_set(x_3138, 2, x_3136);
-lean_ctor_set(x_3138, 3, x_3137);
-lean_ctor_set_uint8(x_3138, sizeof(void*)*4, x_2787);
-x_3139 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_3139, 0, x_3138);
-lean_ctor_set(x_3139, 1, x_2);
-lean_ctor_set(x_3139, 2, x_3);
-lean_ctor_set(x_3139, 3, x_4);
-lean_ctor_set_uint8(x_3139, sizeof(void*)*4, x_2787);
-return x_3139;
-}
+uint8_t x_2039; lean_object* x_2040; 
+x_2039 = 1;
+x_2040 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_2040, 0, x_1);
+lean_ctor_set(x_2040, 1, x_2);
+lean_ctor_set(x_2040, 2, x_3);
+lean_ctor_set(x_2040, 3, x_4);
+lean_ctor_set_uint8(x_2040, sizeof(void*)*4, x_2039);
+return x_2040;
 }
 }
 }
@@ -20239,6 +16015,44 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_balance_u2083___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_setRed_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+uint8_t 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_dec(x_3);
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 2);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 3);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_box(x_5);
+x_11 = lean_apply_5(x_2, x_10, x_6, x_7, x_8, x_9);
+return x_11;
+}
+}
+}
+lean_object* l_Std_RBNode_setRed_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_setRed_match__1___rarg), 3, 0);
+return x_4;
+}
+}
 lean_object* l_Std_RBNode_setRed___rarg(lean_object* x_1) {
 _start:
 {
@@ -20289,6 +16103,437 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_setRed___rarg), 1, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_balLeft_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_dec(x_5);
+if (lean_obj_tag(x_4) == 0)
+{
+lean_object* x_9; 
+lean_dec(x_7);
+lean_dec(x_6);
+x_9 = lean_apply_4(x_8, x_4, x_2, x_3, x_4);
+return x_9;
+}
+else
+{
+uint8_t x_10; 
+x_10 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_10 == 0)
+{
+lean_object* x_11; 
+lean_dec(x_6);
+x_11 = lean_ctor_get(x_4, 0);
+lean_inc(x_11);
+if (lean_obj_tag(x_11) == 0)
+{
+lean_object* x_12; 
+lean_dec(x_7);
+x_12 = lean_apply_4(x_8, x_11, x_2, x_3, x_4);
+return x_12;
+}
+else
+{
+uint8_t x_13; 
+x_13 = lean_ctor_get_uint8(x_11, sizeof(void*)*4);
+if (x_13 == 0)
+{
+uint8_t x_14; 
+lean_dec(x_7);
+x_14 = !lean_is_exclusive(x_4);
+if (x_14 == 0)
+{
+lean_object* x_15; lean_object* x_16; 
+x_15 = lean_ctor_get(x_4, 0);
+lean_dec(x_15);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_13);
+x_16 = lean_apply_4(x_8, x_1, x_2, x_3, x_4);
+return x_16;
+}
+else
+{
+lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+x_17 = lean_ctor_get(x_4, 1);
+x_18 = lean_ctor_get(x_4, 2);
+x_19 = lean_ctor_get(x_4, 3);
+lean_inc(x_19);
+lean_inc(x_18);
+lean_inc(x_17);
+lean_dec(x_4);
+x_20 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_20, 0, x_11);
+lean_ctor_set(x_20, 1, x_17);
+lean_ctor_set(x_20, 2, x_18);
+lean_ctor_set(x_20, 3, x_19);
+lean_ctor_set_uint8(x_20, sizeof(void*)*4, x_13);
+x_21 = lean_apply_4(x_8, x_1, x_2, x_3, x_20);
+return x_21;
+}
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; 
+lean_dec(x_8);
+x_22 = lean_ctor_get(x_4, 1);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_4, 2);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_4, 3);
+lean_inc(x_24);
+lean_dec(x_4);
+x_25 = lean_ctor_get(x_11, 0);
+lean_inc(x_25);
+x_26 = lean_ctor_get(x_11, 1);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_11, 2);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_11, 3);
+lean_inc(x_28);
+lean_dec(x_11);
+x_29 = lean_apply_10(x_7, x_1, x_2, x_3, x_25, x_26, x_27, x_28, x_22, x_23, x_24);
+return x_29;
+}
+}
+}
+else
+{
+lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; 
+lean_dec(x_8);
+lean_dec(x_7);
+x_30 = lean_ctor_get(x_4, 0);
+lean_inc(x_30);
+x_31 = lean_ctor_get(x_4, 1);
+lean_inc(x_31);
+x_32 = lean_ctor_get(x_4, 2);
+lean_inc(x_32);
+x_33 = lean_ctor_get(x_4, 3);
+lean_inc(x_33);
+lean_dec(x_4);
+x_34 = lean_apply_7(x_6, x_1, x_2, x_3, x_30, x_31, x_32, x_33);
+return x_34;
+}
+}
+}
+else
+{
+uint8_t x_35; 
+x_35 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_35 == 0)
+{
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_4) == 0)
+{
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; 
+x_36 = lean_ctor_get(x_1, 0);
+lean_inc(x_36);
+x_37 = lean_ctor_get(x_1, 1);
+lean_inc(x_37);
+x_38 = lean_ctor_get(x_1, 2);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_1, 3);
+lean_inc(x_39);
+lean_dec(x_1);
+x_40 = lean_apply_7(x_5, x_36, x_37, x_38, x_39, x_2, x_3, x_4);
+return x_40;
+}
+else
+{
+uint8_t x_41; 
+x_41 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_41 == 0)
+{
+lean_object* x_42; 
+x_42 = lean_ctor_get(x_4, 0);
+lean_inc(x_42);
+if (lean_obj_tag(x_42) == 0)
+{
+lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; 
+x_43 = lean_ctor_get(x_1, 0);
+lean_inc(x_43);
+x_44 = lean_ctor_get(x_1, 1);
+lean_inc(x_44);
+x_45 = lean_ctor_get(x_1, 2);
+lean_inc(x_45);
+x_46 = lean_ctor_get(x_1, 3);
+lean_inc(x_46);
+lean_dec(x_1);
+x_47 = lean_apply_7(x_5, x_43, x_44, x_45, x_46, x_2, x_3, x_4);
+return x_47;
+}
+else
+{
+uint8_t x_48; 
+x_48 = lean_ctor_get_uint8(x_42, sizeof(void*)*4);
+if (x_48 == 0)
+{
+lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; 
+x_49 = lean_ctor_get(x_1, 0);
+lean_inc(x_49);
+x_50 = lean_ctor_get(x_1, 1);
+lean_inc(x_50);
+x_51 = lean_ctor_get(x_1, 2);
+lean_inc(x_51);
+x_52 = lean_ctor_get(x_1, 3);
+lean_inc(x_52);
+lean_dec(x_1);
+x_53 = !lean_is_exclusive(x_4);
+if (x_53 == 0)
+{
+lean_object* x_54; lean_object* x_55; 
+x_54 = lean_ctor_get(x_4, 0);
+lean_dec(x_54);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_48);
+x_55 = lean_apply_7(x_5, x_49, x_50, x_51, x_52, x_2, x_3, x_4);
+return x_55;
+}
+else
+{
+lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; 
+x_56 = lean_ctor_get(x_4, 1);
+x_57 = lean_ctor_get(x_4, 2);
+x_58 = lean_ctor_get(x_4, 3);
+lean_inc(x_58);
+lean_inc(x_57);
+lean_inc(x_56);
+lean_dec(x_4);
+x_59 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_59, 0, x_42);
+lean_ctor_set(x_59, 1, x_56);
+lean_ctor_set(x_59, 2, x_57);
+lean_ctor_set(x_59, 3, x_58);
+lean_ctor_set_uint8(x_59, sizeof(void*)*4, x_48);
+x_60 = lean_apply_7(x_5, x_49, x_50, x_51, x_52, x_2, x_3, x_59);
+return x_60;
+}
+}
+else
+{
+lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; 
+lean_dec(x_42);
+x_61 = lean_ctor_get(x_1, 0);
+lean_inc(x_61);
+x_62 = lean_ctor_get(x_1, 1);
+lean_inc(x_62);
+x_63 = lean_ctor_get(x_1, 2);
+lean_inc(x_63);
+x_64 = lean_ctor_get(x_1, 3);
+lean_inc(x_64);
+lean_dec(x_1);
+x_65 = lean_apply_7(x_5, x_61, x_62, x_63, x_64, x_2, x_3, x_4);
+return x_65;
+}
+}
+}
+else
+{
+lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; 
+x_66 = lean_ctor_get(x_1, 0);
+lean_inc(x_66);
+x_67 = lean_ctor_get(x_1, 1);
+lean_inc(x_67);
+x_68 = lean_ctor_get(x_1, 2);
+lean_inc(x_68);
+x_69 = lean_ctor_get(x_1, 3);
+lean_inc(x_69);
+lean_dec(x_1);
+x_70 = lean_apply_7(x_5, x_66, x_67, x_68, x_69, x_2, x_3, x_4);
+return x_70;
+}
+}
+}
+else
+{
+lean_dec(x_5);
+if (lean_obj_tag(x_4) == 0)
+{
+lean_object* x_71; 
+lean_dec(x_7);
+lean_dec(x_6);
+x_71 = lean_apply_4(x_8, x_1, x_2, x_3, x_4);
+return x_71;
+}
+else
+{
+uint8_t x_72; 
+x_72 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_72 == 0)
+{
+lean_object* x_73; 
+lean_dec(x_6);
+x_73 = lean_ctor_get(x_4, 0);
+lean_inc(x_73);
+if (lean_obj_tag(x_73) == 0)
+{
+lean_object* x_74; 
+lean_dec(x_7);
+x_74 = lean_apply_4(x_8, x_1, x_2, x_3, x_4);
+return x_74;
+}
+else
+{
+uint8_t x_75; 
+x_75 = lean_ctor_get_uint8(x_73, sizeof(void*)*4);
+if (x_75 == 0)
+{
+uint8_t x_76; 
+lean_dec(x_7);
+x_76 = !lean_is_exclusive(x_4);
+if (x_76 == 0)
+{
+lean_object* x_77; lean_object* x_78; 
+x_77 = lean_ctor_get(x_4, 0);
+lean_dec(x_77);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_75);
+x_78 = lean_apply_4(x_8, x_1, x_2, x_3, x_4);
+return x_78;
+}
+else
+{
+lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; 
+x_79 = lean_ctor_get(x_4, 1);
+x_80 = lean_ctor_get(x_4, 2);
+x_81 = lean_ctor_get(x_4, 3);
+lean_inc(x_81);
+lean_inc(x_80);
+lean_inc(x_79);
+lean_dec(x_4);
+x_82 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_82, 0, x_73);
+lean_ctor_set(x_82, 1, x_79);
+lean_ctor_set(x_82, 2, x_80);
+lean_ctor_set(x_82, 3, x_81);
+lean_ctor_set_uint8(x_82, sizeof(void*)*4, x_75);
+x_83 = lean_apply_4(x_8, x_1, x_2, x_3, x_82);
+return x_83;
+}
+}
+else
+{
+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; uint8_t x_91; 
+lean_dec(x_8);
+x_84 = lean_ctor_get(x_1, 0);
+lean_inc(x_84);
+x_85 = lean_ctor_get(x_1, 1);
+lean_inc(x_85);
+x_86 = lean_ctor_get(x_1, 2);
+lean_inc(x_86);
+x_87 = lean_ctor_get(x_1, 3);
+lean_inc(x_87);
+lean_dec(x_1);
+x_88 = lean_ctor_get(x_4, 1);
+lean_inc(x_88);
+x_89 = lean_ctor_get(x_4, 2);
+lean_inc(x_89);
+x_90 = lean_ctor_get(x_4, 3);
+lean_inc(x_90);
+lean_dec(x_4);
+x_91 = !lean_is_exclusive(x_73);
+if (x_91 == 0)
+{
+lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; 
+x_92 = lean_ctor_get(x_73, 0);
+x_93 = lean_ctor_get(x_73, 1);
+x_94 = lean_ctor_get(x_73, 2);
+x_95 = lean_ctor_get(x_73, 3);
+lean_ctor_set(x_73, 3, x_87);
+lean_ctor_set(x_73, 2, x_86);
+lean_ctor_set(x_73, 1, x_85);
+lean_ctor_set(x_73, 0, x_84);
+x_96 = lean_apply_10(x_7, x_73, x_2, x_3, x_92, x_93, x_94, x_95, x_88, x_89, x_90);
+return x_96;
+}
+else
+{
+lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; 
+x_97 = lean_ctor_get(x_73, 0);
+x_98 = lean_ctor_get(x_73, 1);
+x_99 = lean_ctor_get(x_73, 2);
+x_100 = lean_ctor_get(x_73, 3);
+lean_inc(x_100);
+lean_inc(x_99);
+lean_inc(x_98);
+lean_inc(x_97);
+lean_dec(x_73);
+x_101 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_101, 0, x_84);
+lean_ctor_set(x_101, 1, x_85);
+lean_ctor_set(x_101, 2, x_86);
+lean_ctor_set(x_101, 3, x_87);
+lean_ctor_set_uint8(x_101, sizeof(void*)*4, x_75);
+x_102 = lean_apply_10(x_7, x_101, x_2, x_3, x_97, x_98, x_99, x_100, x_88, x_89, x_90);
+return x_102;
+}
+}
+}
+}
+else
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; 
+lean_dec(x_8);
+lean_dec(x_7);
+x_103 = lean_ctor_get(x_1, 0);
+lean_inc(x_103);
+x_104 = lean_ctor_get(x_1, 1);
+lean_inc(x_104);
+x_105 = lean_ctor_get(x_1, 2);
+lean_inc(x_105);
+x_106 = lean_ctor_get(x_1, 3);
+lean_inc(x_106);
+lean_dec(x_1);
+x_107 = !lean_is_exclusive(x_4);
+if (x_107 == 0)
+{
+lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; 
+x_108 = lean_ctor_get(x_4, 0);
+x_109 = lean_ctor_get(x_4, 1);
+x_110 = lean_ctor_get(x_4, 2);
+x_111 = lean_ctor_get(x_4, 3);
+lean_ctor_set(x_4, 3, x_106);
+lean_ctor_set(x_4, 2, x_105);
+lean_ctor_set(x_4, 1, x_104);
+lean_ctor_set(x_4, 0, x_103);
+x_112 = lean_apply_7(x_6, x_4, x_2, x_3, x_108, x_109, x_110, x_111);
+return x_112;
+}
+else
+{
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; 
+x_113 = lean_ctor_get(x_4, 0);
+x_114 = lean_ctor_get(x_4, 1);
+x_115 = lean_ctor_get(x_4, 2);
+x_116 = lean_ctor_get(x_4, 3);
+lean_inc(x_116);
+lean_inc(x_115);
+lean_inc(x_114);
+lean_inc(x_113);
+lean_dec(x_4);
+x_117 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_117, 0, x_103);
+lean_ctor_set(x_117, 1, x_104);
+lean_ctor_set(x_117, 2, x_105);
+lean_ctor_set(x_117, 3, x_106);
+lean_ctor_set_uint8(x_117, sizeof(void*)*4, x_72);
+x_118 = lean_apply_7(x_6, x_117, x_2, x_3, x_113, x_114, x_115, x_116);
+return x_118;
+}
+}
+}
+}
+}
+}
+}
+lean_object* l_Std_RBNode_balLeft_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_balLeft_match__1___rarg), 8, 0);
+return x_4;
+}
+}
 lean_object* l_Std_RBNode_balLeft___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -20317,666 +16562,1020 @@ x_8 = lean_ctor_get(x_4, 0);
 lean_inc(x_8);
 if (lean_obj_tag(x_8) == 0)
 {
-lean_object* x_9; 
-x_9 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_9, 0, x_8);
-lean_ctor_set(x_9, 1, x_2);
-lean_ctor_set(x_9, 2, x_3);
-lean_ctor_set(x_9, 3, x_4);
-lean_ctor_set_uint8(x_9, sizeof(void*)*4, x_7);
-return x_9;
+uint8_t x_9; lean_object* x_10; 
+x_9 = 0;
+x_10 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_10, 0, x_8);
+lean_ctor_set(x_10, 1, x_2);
+lean_ctor_set(x_10, 2, x_3);
+lean_ctor_set(x_10, 3, x_4);
+lean_ctor_set_uint8(x_10, sizeof(void*)*4, x_9);
+return x_10;
 }
 else
 {
-uint8_t x_10; 
-x_10 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
-if (x_10 == 0)
-{
 uint8_t x_11; 
-x_11 = !lean_is_exclusive(x_4);
+x_11 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
 if (x_11 == 0)
 {
-lean_object* x_12; lean_object* x_13; 
-x_12 = lean_ctor_get(x_4, 0);
-lean_dec(x_12);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_10);
-x_13 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_13, 0, x_1);
-lean_ctor_set(x_13, 1, x_2);
-lean_ctor_set(x_13, 2, x_3);
-lean_ctor_set(x_13, 3, x_4);
-lean_ctor_set_uint8(x_13, sizeof(void*)*4, x_10);
-return x_13;
+uint8_t x_12; 
+x_12 = !lean_is_exclusive(x_4);
+if (x_12 == 0)
+{
+lean_object* x_13; uint8_t x_14; lean_object* x_15; 
+x_13 = lean_ctor_get(x_4, 0);
+lean_dec(x_13);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_11);
+x_14 = 0;
+x_15 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_15, 0, x_1);
+lean_ctor_set(x_15, 1, x_2);
+lean_ctor_set(x_15, 2, x_3);
+lean_ctor_set(x_15, 3, x_4);
+lean_ctor_set_uint8(x_15, sizeof(void*)*4, x_14);
+return x_15;
 }
 else
 {
-lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_14 = lean_ctor_get(x_4, 1);
-x_15 = lean_ctor_get(x_4, 2);
-x_16 = lean_ctor_get(x_4, 3);
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; 
+x_16 = lean_ctor_get(x_4, 1);
+x_17 = lean_ctor_get(x_4, 2);
+x_18 = lean_ctor_get(x_4, 3);
+lean_inc(x_18);
+lean_inc(x_17);
 lean_inc(x_16);
-lean_inc(x_15);
-lean_inc(x_14);
 lean_dec(x_4);
-x_17 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_17, 0, x_8);
-lean_ctor_set(x_17, 1, x_14);
-lean_ctor_set(x_17, 2, x_15);
-lean_ctor_set(x_17, 3, x_16);
-lean_ctor_set_uint8(x_17, sizeof(void*)*4, x_10);
-x_18 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_18, 0, x_1);
-lean_ctor_set(x_18, 1, x_2);
-lean_ctor_set(x_18, 2, x_3);
-lean_ctor_set(x_18, 3, x_17);
-lean_ctor_set_uint8(x_18, sizeof(void*)*4, x_10);
-return x_18;
+x_19 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_19, 0, x_8);
+lean_ctor_set(x_19, 1, x_16);
+lean_ctor_set(x_19, 2, x_17);
+lean_ctor_set(x_19, 3, x_18);
+lean_ctor_set_uint8(x_19, sizeof(void*)*4, x_11);
+x_20 = 0;
+x_21 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_21, 0, x_1);
+lean_ctor_set(x_21, 1, x_2);
+lean_ctor_set(x_21, 2, x_3);
+lean_ctor_set(x_21, 3, x_19);
+lean_ctor_set_uint8(x_21, sizeof(void*)*4, x_20);
+return x_21;
 }
 }
 else
 {
-uint8_t x_19; 
-x_19 = !lean_is_exclusive(x_4);
-if (x_19 == 0)
+uint8_t x_22; 
+x_22 = !lean_is_exclusive(x_4);
+if (x_22 == 0)
 {
-lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; 
-x_20 = lean_ctor_get(x_4, 1);
-x_21 = lean_ctor_get(x_4, 2);
-x_22 = lean_ctor_get(x_4, 3);
-x_23 = lean_ctor_get(x_4, 0);
-lean_dec(x_23);
-x_24 = !lean_is_exclusive(x_8);
-if (x_24 == 0)
+lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; uint8_t x_27; 
+x_23 = lean_ctor_get(x_4, 1);
+x_24 = lean_ctor_get(x_4, 2);
+x_25 = lean_ctor_get(x_4, 3);
+x_26 = lean_ctor_get(x_4, 0);
+lean_dec(x_26);
+x_27 = !lean_is_exclusive(x_8);
+if (x_27 == 0)
 {
-lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
-x_25 = lean_ctor_get(x_8, 0);
-x_26 = lean_ctor_get(x_8, 1);
-x_27 = lean_ctor_get(x_8, 2);
-x_28 = lean_ctor_get(x_8, 3);
-lean_ctor_set(x_8, 3, x_25);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; 
+x_28 = lean_ctor_get(x_8, 0);
+x_29 = lean_ctor_get(x_8, 1);
+x_30 = lean_ctor_get(x_8, 2);
+x_31 = lean_ctor_get(x_8, 3);
+x_32 = 1;
+lean_ctor_set(x_8, 3, x_28);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
 lean_ctor_set(x_8, 0, x_1);
-x_29 = l_Std_RBNode_setRed___rarg(x_22);
-x_30 = l_Std_RBNode_balance_u2083___rarg(x_28, x_20, x_21, x_29);
-lean_ctor_set(x_4, 3, x_30);
-lean_ctor_set(x_4, 2, x_27);
-lean_ctor_set(x_4, 1, x_26);
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_32);
+x_33 = l_Std_RBNode_setRed___rarg(x_25);
+x_34 = l_Std_RBNode_balance_u2083___rarg(x_31, x_23, x_24, x_33);
+x_35 = 0;
+lean_ctor_set(x_4, 3, x_34);
+lean_ctor_set(x_4, 2, x_30);
+lean_ctor_set(x_4, 1, x_29);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_35);
 return x_4;
 }
 else
 {
-lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; 
-x_31 = lean_ctor_get(x_8, 0);
-x_32 = lean_ctor_get(x_8, 1);
-x_33 = lean_ctor_get(x_8, 2);
-x_34 = lean_ctor_get(x_8, 3);
-lean_inc(x_34);
-lean_inc(x_33);
-lean_inc(x_32);
-lean_inc(x_31);
-lean_dec(x_8);
-x_35 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_35, 0, x_1);
-lean_ctor_set(x_35, 1, x_2);
-lean_ctor_set(x_35, 2, x_3);
-lean_ctor_set(x_35, 3, x_31);
-lean_ctor_set_uint8(x_35, sizeof(void*)*4, x_10);
-x_36 = l_Std_RBNode_setRed___rarg(x_22);
-x_37 = l_Std_RBNode_balance_u2083___rarg(x_34, x_20, x_21, x_36);
-lean_ctor_set(x_4, 3, x_37);
-lean_ctor_set(x_4, 2, x_33);
-lean_ctor_set(x_4, 1, x_32);
-lean_ctor_set(x_4, 0, x_35);
-return x_4;
-}
-}
-else
-{
-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; 
-x_38 = lean_ctor_get(x_4, 1);
-x_39 = lean_ctor_get(x_4, 2);
-x_40 = lean_ctor_get(x_4, 3);
-lean_inc(x_40);
+lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; 
+x_36 = lean_ctor_get(x_8, 0);
+x_37 = lean_ctor_get(x_8, 1);
+x_38 = lean_ctor_get(x_8, 2);
+x_39 = lean_ctor_get(x_8, 3);
 lean_inc(x_39);
 lean_inc(x_38);
+lean_inc(x_37);
+lean_inc(x_36);
+lean_dec(x_8);
+x_40 = 1;
+x_41 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_41, 0, x_1);
+lean_ctor_set(x_41, 1, x_2);
+lean_ctor_set(x_41, 2, x_3);
+lean_ctor_set(x_41, 3, x_36);
+lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_40);
+x_42 = l_Std_RBNode_setRed___rarg(x_25);
+x_43 = l_Std_RBNode_balance_u2083___rarg(x_39, x_23, x_24, x_42);
+x_44 = 0;
+lean_ctor_set(x_4, 3, x_43);
+lean_ctor_set(x_4, 2, x_38);
+lean_ctor_set(x_4, 1, x_37);
+lean_ctor_set(x_4, 0, x_41);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_44);
+return x_4;
+}
+}
+else
+{
+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; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; 
+x_45 = lean_ctor_get(x_4, 1);
+x_46 = lean_ctor_get(x_4, 2);
+x_47 = lean_ctor_get(x_4, 3);
+lean_inc(x_47);
+lean_inc(x_46);
+lean_inc(x_45);
 lean_dec(x_4);
-x_41 = lean_ctor_get(x_8, 0);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_8, 1);
-lean_inc(x_42);
-x_43 = lean_ctor_get(x_8, 2);
-lean_inc(x_43);
-x_44 = lean_ctor_get(x_8, 3);
-lean_inc(x_44);
+x_48 = lean_ctor_get(x_8, 0);
+lean_inc(x_48);
+x_49 = lean_ctor_get(x_8, 1);
+lean_inc(x_49);
+x_50 = lean_ctor_get(x_8, 2);
+lean_inc(x_50);
+x_51 = lean_ctor_get(x_8, 3);
+lean_inc(x_51);
 if (lean_is_exclusive(x_8)) {
  lean_ctor_release(x_8, 0);
  lean_ctor_release(x_8, 1);
  lean_ctor_release(x_8, 2);
  lean_ctor_release(x_8, 3);
- x_45 = x_8;
+ x_52 = x_8;
 } else {
  lean_dec_ref(x_8);
- x_45 = lean_box(0);
+ x_52 = lean_box(0);
 }
-if (lean_is_scalar(x_45)) {
- x_46 = lean_alloc_ctor(1, 4, 1);
+x_53 = 1;
+if (lean_is_scalar(x_52)) {
+ x_54 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_46 = x_45;
+ x_54 = x_52;
 }
-lean_ctor_set(x_46, 0, x_1);
-lean_ctor_set(x_46, 1, x_2);
-lean_ctor_set(x_46, 2, x_3);
-lean_ctor_set(x_46, 3, x_41);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_10);
-x_47 = l_Std_RBNode_setRed___rarg(x_40);
-x_48 = l_Std_RBNode_balance_u2083___rarg(x_44, x_38, x_39, x_47);
-x_49 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_49, 0, x_46);
-lean_ctor_set(x_49, 1, x_42);
-lean_ctor_set(x_49, 2, x_43);
-lean_ctor_set(x_49, 3, x_48);
-lean_ctor_set_uint8(x_49, sizeof(void*)*4, x_7);
-return x_49;
-}
-}
-}
-}
-else
-{
-uint8_t x_50; 
-x_50 = !lean_is_exclusive(x_4);
-if (x_50 == 0)
-{
-uint8_t x_51; lean_object* x_52; 
-x_51 = 0;
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_51);
-x_52 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_4);
-return x_52;
-}
-else
-{
-lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; 
-x_53 = lean_ctor_get(x_4, 0);
-x_54 = lean_ctor_get(x_4, 1);
-x_55 = lean_ctor_get(x_4, 2);
-x_56 = lean_ctor_get(x_4, 3);
-lean_inc(x_56);
-lean_inc(x_55);
-lean_inc(x_54);
-lean_inc(x_53);
-lean_dec(x_4);
+lean_ctor_set(x_54, 0, x_1);
+lean_ctor_set(x_54, 1, x_2);
+lean_ctor_set(x_54, 2, x_3);
+lean_ctor_set(x_54, 3, x_48);
+lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_53);
+x_55 = l_Std_RBNode_setRed___rarg(x_47);
+x_56 = l_Std_RBNode_balance_u2083___rarg(x_51, x_45, x_46, x_55);
 x_57 = 0;
 x_58 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_58, 0, x_53);
-lean_ctor_set(x_58, 1, x_54);
-lean_ctor_set(x_58, 2, x_55);
+lean_ctor_set(x_58, 0, x_54);
+lean_ctor_set(x_58, 1, x_49);
+lean_ctor_set(x_58, 2, x_50);
 lean_ctor_set(x_58, 3, x_56);
 lean_ctor_set_uint8(x_58, sizeof(void*)*4, x_57);
-x_59 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_58);
-return x_59;
+return x_58;
 }
 }
 }
 }
 else
 {
-uint8_t x_60; 
-x_60 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_60 == 0)
+uint8_t x_59; 
+x_59 = !lean_is_exclusive(x_4);
+if (x_59 == 0)
 {
-uint8_t x_61; 
-x_61 = !lean_is_exclusive(x_1);
-if (x_61 == 0)
-{
-uint8_t x_62; lean_object* x_63; 
-x_62 = 1;
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_62);
-x_63 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_63, 0, x_1);
-lean_ctor_set(x_63, 1, x_2);
-lean_ctor_set(x_63, 2, x_3);
-lean_ctor_set(x_63, 3, x_4);
-lean_ctor_set_uint8(x_63, sizeof(void*)*4, x_60);
-return x_63;
+uint8_t x_60; lean_object* x_61; 
+x_60 = 0;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_60);
+x_61 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_4);
+return x_61;
 }
 else
 {
-lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; 
-x_64 = lean_ctor_get(x_1, 0);
-x_65 = lean_ctor_get(x_1, 1);
-x_66 = lean_ctor_get(x_1, 2);
-x_67 = lean_ctor_get(x_1, 3);
-lean_inc(x_67);
-lean_inc(x_66);
+lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; lean_object* x_67; lean_object* x_68; 
+x_62 = lean_ctor_get(x_4, 0);
+x_63 = lean_ctor_get(x_4, 1);
+x_64 = lean_ctor_get(x_4, 2);
+x_65 = lean_ctor_get(x_4, 3);
 lean_inc(x_65);
 lean_inc(x_64);
+lean_inc(x_63);
+lean_inc(x_62);
+lean_dec(x_4);
+x_66 = 0;
+x_67 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_67, 0, x_62);
+lean_ctor_set(x_67, 1, x_63);
+lean_ctor_set(x_67, 2, x_64);
+lean_ctor_set(x_67, 3, x_65);
+lean_ctor_set_uint8(x_67, sizeof(void*)*4, x_66);
+x_68 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_67);
+return x_68;
+}
+}
+}
+}
+else
+{
+uint8_t x_69; 
+x_69 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_69 == 0)
+{
+if (lean_obj_tag(x_4) == 0)
+{
+uint8_t x_70; 
+x_70 = !lean_is_exclusive(x_1);
+if (x_70 == 0)
+{
+uint8_t x_71; uint8_t x_72; lean_object* x_73; 
+x_71 = 1;
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_71);
+x_72 = 0;
+x_73 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_73, 0, x_1);
+lean_ctor_set(x_73, 1, x_2);
+lean_ctor_set(x_73, 2, x_3);
+lean_ctor_set(x_73, 3, x_4);
+lean_ctor_set_uint8(x_73, sizeof(void*)*4, x_72);
+return x_73;
+}
+else
+{
+lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; uint8_t x_80; lean_object* x_81; 
+x_74 = lean_ctor_get(x_1, 0);
+x_75 = lean_ctor_get(x_1, 1);
+x_76 = lean_ctor_get(x_1, 2);
+x_77 = lean_ctor_get(x_1, 3);
+lean_inc(x_77);
+lean_inc(x_76);
+lean_inc(x_75);
+lean_inc(x_74);
 lean_dec(x_1);
-x_68 = 1;
-x_69 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_69, 0, x_64);
-lean_ctor_set(x_69, 1, x_65);
-lean_ctor_set(x_69, 2, x_66);
-lean_ctor_set(x_69, 3, x_67);
-lean_ctor_set_uint8(x_69, sizeof(void*)*4, x_68);
-x_70 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_70, 0, x_69);
-lean_ctor_set(x_70, 1, x_2);
-lean_ctor_set(x_70, 2, x_3);
-lean_ctor_set(x_70, 3, x_4);
-lean_ctor_set_uint8(x_70, sizeof(void*)*4, x_60);
-return x_70;
+x_78 = 1;
+x_79 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_79, 0, x_74);
+lean_ctor_set(x_79, 1, x_75);
+lean_ctor_set(x_79, 2, x_76);
+lean_ctor_set(x_79, 3, x_77);
+lean_ctor_set_uint8(x_79, sizeof(void*)*4, x_78);
+x_80 = 0;
+x_81 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_81, 0, x_79);
+lean_ctor_set(x_81, 1, x_2);
+lean_ctor_set(x_81, 2, x_3);
+lean_ctor_set(x_81, 3, x_4);
+lean_ctor_set_uint8(x_81, sizeof(void*)*4, x_80);
+return x_81;
+}
+}
+else
+{
+uint8_t x_82; 
+x_82 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_82 == 0)
+{
+lean_object* x_83; 
+x_83 = lean_ctor_get(x_4, 0);
+lean_inc(x_83);
+if (lean_obj_tag(x_83) == 0)
+{
+uint8_t x_84; 
+x_84 = !lean_is_exclusive(x_1);
+if (x_84 == 0)
+{
+uint8_t x_85; uint8_t x_86; lean_object* x_87; 
+x_85 = 1;
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_85);
+x_86 = 0;
+x_87 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_87, 0, x_1);
+lean_ctor_set(x_87, 1, x_2);
+lean_ctor_set(x_87, 2, x_3);
+lean_ctor_set(x_87, 3, x_4);
+lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_86);
+return x_87;
+}
+else
+{
+lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; uint8_t x_92; lean_object* x_93; uint8_t x_94; lean_object* x_95; 
+x_88 = lean_ctor_get(x_1, 0);
+x_89 = lean_ctor_get(x_1, 1);
+x_90 = lean_ctor_get(x_1, 2);
+x_91 = lean_ctor_get(x_1, 3);
+lean_inc(x_91);
+lean_inc(x_90);
+lean_inc(x_89);
+lean_inc(x_88);
+lean_dec(x_1);
+x_92 = 1;
+x_93 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_93, 0, x_88);
+lean_ctor_set(x_93, 1, x_89);
+lean_ctor_set(x_93, 2, x_90);
+lean_ctor_set(x_93, 3, x_91);
+lean_ctor_set_uint8(x_93, sizeof(void*)*4, x_92);
+x_94 = 0;
+x_95 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_95, 0, x_93);
+lean_ctor_set(x_95, 1, x_2);
+lean_ctor_set(x_95, 2, x_3);
+lean_ctor_set(x_95, 3, x_4);
+lean_ctor_set_uint8(x_95, sizeof(void*)*4, x_94);
+return x_95;
+}
+}
+else
+{
+uint8_t x_96; 
+x_96 = lean_ctor_get_uint8(x_83, sizeof(void*)*4);
+if (x_96 == 0)
+{
+uint8_t x_97; 
+x_97 = !lean_is_exclusive(x_1);
+if (x_97 == 0)
+{
+uint8_t x_98; 
+x_98 = !lean_is_exclusive(x_4);
+if (x_98 == 0)
+{
+lean_object* x_99; uint8_t x_100; uint8_t x_101; lean_object* x_102; 
+x_99 = lean_ctor_get(x_4, 0);
+lean_dec(x_99);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_96);
+x_100 = 1;
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_100);
+x_101 = 0;
+x_102 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_102, 0, x_1);
+lean_ctor_set(x_102, 1, x_2);
+lean_ctor_set(x_102, 2, x_3);
+lean_ctor_set(x_102, 3, x_4);
+lean_ctor_set_uint8(x_102, sizeof(void*)*4, x_101);
+return x_102;
+}
+else
+{
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; lean_object* x_109; 
+x_103 = lean_ctor_get(x_4, 1);
+x_104 = lean_ctor_get(x_4, 2);
+x_105 = lean_ctor_get(x_4, 3);
+lean_inc(x_105);
+lean_inc(x_104);
+lean_inc(x_103);
+lean_dec(x_4);
+x_106 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_106, 0, x_83);
+lean_ctor_set(x_106, 1, x_103);
+lean_ctor_set(x_106, 2, x_104);
+lean_ctor_set(x_106, 3, x_105);
+lean_ctor_set_uint8(x_106, sizeof(void*)*4, x_96);
+x_107 = 1;
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_107);
+x_108 = 0;
+x_109 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_109, 0, x_1);
+lean_ctor_set(x_109, 1, x_2);
+lean_ctor_set(x_109, 2, x_3);
+lean_ctor_set(x_109, 3, x_106);
+lean_ctor_set_uint8(x_109, sizeof(void*)*4, x_108);
+return x_109;
+}
+}
+else
+{
+lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; uint8_t x_119; lean_object* x_120; uint8_t x_121; lean_object* x_122; 
+x_110 = lean_ctor_get(x_1, 0);
+x_111 = lean_ctor_get(x_1, 1);
+x_112 = lean_ctor_get(x_1, 2);
+x_113 = lean_ctor_get(x_1, 3);
+lean_inc(x_113);
+lean_inc(x_112);
+lean_inc(x_111);
+lean_inc(x_110);
+lean_dec(x_1);
+x_114 = lean_ctor_get(x_4, 1);
+lean_inc(x_114);
+x_115 = lean_ctor_get(x_4, 2);
+lean_inc(x_115);
+x_116 = lean_ctor_get(x_4, 3);
+lean_inc(x_116);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_117 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_117 = lean_box(0);
+}
+if (lean_is_scalar(x_117)) {
+ x_118 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_118 = x_117;
+}
+lean_ctor_set(x_118, 0, x_83);
+lean_ctor_set(x_118, 1, x_114);
+lean_ctor_set(x_118, 2, x_115);
+lean_ctor_set(x_118, 3, x_116);
+lean_ctor_set_uint8(x_118, sizeof(void*)*4, x_96);
+x_119 = 1;
+x_120 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_120, 0, x_110);
+lean_ctor_set(x_120, 1, x_111);
+lean_ctor_set(x_120, 2, x_112);
+lean_ctor_set(x_120, 3, x_113);
+lean_ctor_set_uint8(x_120, sizeof(void*)*4, x_119);
+x_121 = 0;
+x_122 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_122, 0, x_120);
+lean_ctor_set(x_122, 1, x_2);
+lean_ctor_set(x_122, 2, x_3);
+lean_ctor_set(x_122, 3, x_118);
+lean_ctor_set_uint8(x_122, sizeof(void*)*4, x_121);
+return x_122;
+}
+}
+else
+{
+uint8_t x_123; 
+x_123 = !lean_is_exclusive(x_83);
+if (x_123 == 0)
+{
+lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; uint8_t x_128; 
+x_124 = lean_ctor_get(x_83, 3);
+lean_dec(x_124);
+x_125 = lean_ctor_get(x_83, 2);
+lean_dec(x_125);
+x_126 = lean_ctor_get(x_83, 1);
+lean_dec(x_126);
+x_127 = lean_ctor_get(x_83, 0);
+lean_dec(x_127);
+x_128 = !lean_is_exclusive(x_1);
+if (x_128 == 0)
+{
+lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; uint8_t x_133; uint8_t x_134; 
+x_129 = lean_ctor_get(x_1, 0);
+x_130 = lean_ctor_get(x_1, 1);
+x_131 = lean_ctor_get(x_1, 2);
+x_132 = lean_ctor_get(x_1, 3);
+x_133 = 1;
+lean_ctor_set(x_83, 3, x_132);
+lean_ctor_set(x_83, 2, x_131);
+lean_ctor_set(x_83, 1, x_130);
+lean_ctor_set(x_83, 0, x_129);
+lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_133);
+x_134 = 0;
+lean_ctor_set(x_1, 3, x_4);
+lean_ctor_set(x_1, 2, x_3);
+lean_ctor_set(x_1, 1, x_2);
+lean_ctor_set(x_1, 0, x_83);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_134);
+return x_1;
+}
+else
+{
+lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; uint8_t x_140; lean_object* x_141; 
+x_135 = lean_ctor_get(x_1, 0);
+x_136 = lean_ctor_get(x_1, 1);
+x_137 = lean_ctor_get(x_1, 2);
+x_138 = lean_ctor_get(x_1, 3);
+lean_inc(x_138);
+lean_inc(x_137);
+lean_inc(x_136);
+lean_inc(x_135);
+lean_dec(x_1);
+x_139 = 1;
+lean_ctor_set(x_83, 3, x_138);
+lean_ctor_set(x_83, 2, x_137);
+lean_ctor_set(x_83, 1, x_136);
+lean_ctor_set(x_83, 0, x_135);
+lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_139);
+x_140 = 0;
+x_141 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_141, 0, x_83);
+lean_ctor_set(x_141, 1, x_2);
+lean_ctor_set(x_141, 2, x_3);
+lean_ctor_set(x_141, 3, x_4);
+lean_ctor_set_uint8(x_141, sizeof(void*)*4, x_140);
+return x_141;
+}
+}
+else
+{
+lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; uint8_t x_149; lean_object* x_150; 
+lean_dec(x_83);
+x_142 = lean_ctor_get(x_1, 0);
+lean_inc(x_142);
+x_143 = lean_ctor_get(x_1, 1);
+lean_inc(x_143);
+x_144 = lean_ctor_get(x_1, 2);
+lean_inc(x_144);
+x_145 = lean_ctor_get(x_1, 3);
+lean_inc(x_145);
+if (lean_is_exclusive(x_1)) {
+ lean_ctor_release(x_1, 0);
+ lean_ctor_release(x_1, 1);
+ lean_ctor_release(x_1, 2);
+ lean_ctor_release(x_1, 3);
+ x_146 = x_1;
+} else {
+ lean_dec_ref(x_1);
+ x_146 = lean_box(0);
+}
+x_147 = 1;
+x_148 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_148, 0, x_142);
+lean_ctor_set(x_148, 1, x_143);
+lean_ctor_set(x_148, 2, x_144);
+lean_ctor_set(x_148, 3, x_145);
+lean_ctor_set_uint8(x_148, sizeof(void*)*4, x_147);
+x_149 = 0;
+if (lean_is_scalar(x_146)) {
+ x_150 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_150 = x_146;
+}
+lean_ctor_set(x_150, 0, x_148);
+lean_ctor_set(x_150, 1, x_2);
+lean_ctor_set(x_150, 2, x_3);
+lean_ctor_set(x_150, 3, x_4);
+lean_ctor_set_uint8(x_150, sizeof(void*)*4, x_149);
+return x_150;
+}
+}
+}
+}
+else
+{
+uint8_t x_151; 
+x_151 = !lean_is_exclusive(x_1);
+if (x_151 == 0)
+{
+uint8_t x_152; uint8_t x_153; lean_object* x_154; 
+x_152 = 1;
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_152);
+x_153 = 0;
+x_154 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_154, 0, x_1);
+lean_ctor_set(x_154, 1, x_2);
+lean_ctor_set(x_154, 2, x_3);
+lean_ctor_set(x_154, 3, x_4);
+lean_ctor_set_uint8(x_154, sizeof(void*)*4, x_153);
+return x_154;
+}
+else
+{
+lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; uint8_t x_159; lean_object* x_160; uint8_t x_161; lean_object* x_162; 
+x_155 = lean_ctor_get(x_1, 0);
+x_156 = lean_ctor_get(x_1, 1);
+x_157 = lean_ctor_get(x_1, 2);
+x_158 = lean_ctor_get(x_1, 3);
+lean_inc(x_158);
+lean_inc(x_157);
+lean_inc(x_156);
+lean_inc(x_155);
+lean_dec(x_1);
+x_159 = 1;
+x_160 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_160, 0, x_155);
+lean_ctor_set(x_160, 1, x_156);
+lean_ctor_set(x_160, 2, x_157);
+lean_ctor_set(x_160, 3, x_158);
+lean_ctor_set_uint8(x_160, sizeof(void*)*4, x_159);
+x_161 = 0;
+x_162 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_162, 0, x_160);
+lean_ctor_set(x_162, 1, x_2);
+lean_ctor_set(x_162, 2, x_3);
+lean_ctor_set(x_162, 3, x_4);
+lean_ctor_set_uint8(x_162, sizeof(void*)*4, x_161);
+return x_162;
+}
+}
 }
 }
 else
 {
 if (lean_obj_tag(x_4) == 0)
 {
-uint8_t x_71; lean_object* x_72; 
-x_71 = 0;
-x_72 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_72, 0, x_1);
-lean_ctor_set(x_72, 1, x_2);
-lean_ctor_set(x_72, 2, x_3);
-lean_ctor_set(x_72, 3, x_4);
-lean_ctor_set_uint8(x_72, sizeof(void*)*4, x_71);
-return x_72;
+uint8_t x_163; lean_object* x_164; 
+x_163 = 0;
+x_164 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_164, 0, x_1);
+lean_ctor_set(x_164, 1, x_2);
+lean_ctor_set(x_164, 2, x_3);
+lean_ctor_set(x_164, 3, x_4);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_163);
+return x_164;
 }
 else
 {
-uint8_t x_73; 
-x_73 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
-if (x_73 == 0)
+uint8_t x_165; 
+x_165 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_165 == 0)
 {
-lean_object* x_74; 
-x_74 = lean_ctor_get(x_4, 0);
-lean_inc(x_74);
-if (lean_obj_tag(x_74) == 0)
-{
-lean_object* x_75; 
-x_75 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_75, 0, x_1);
-lean_ctor_set(x_75, 1, x_2);
-lean_ctor_set(x_75, 2, x_3);
-lean_ctor_set(x_75, 3, x_4);
-lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_73);
-return x_75;
-}
-else
-{
-uint8_t x_76; 
-x_76 = lean_ctor_get_uint8(x_74, sizeof(void*)*4);
-if (x_76 == 0)
-{
-uint8_t x_77; 
-x_77 = !lean_is_exclusive(x_4);
-if (x_77 == 0)
-{
-lean_object* x_78; lean_object* x_79; 
-x_78 = lean_ctor_get(x_4, 0);
-lean_dec(x_78);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_76);
-x_79 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_79, 0, x_1);
-lean_ctor_set(x_79, 1, x_2);
-lean_ctor_set(x_79, 2, x_3);
-lean_ctor_set(x_79, 3, x_4);
-lean_ctor_set_uint8(x_79, sizeof(void*)*4, x_76);
-return x_79;
-}
-else
-{
-lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; 
-x_80 = lean_ctor_get(x_4, 1);
-x_81 = lean_ctor_get(x_4, 2);
-x_82 = lean_ctor_get(x_4, 3);
-lean_inc(x_82);
-lean_inc(x_81);
-lean_inc(x_80);
-lean_dec(x_4);
-x_83 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_83, 0, x_74);
-lean_ctor_set(x_83, 1, x_80);
-lean_ctor_set(x_83, 2, x_81);
-lean_ctor_set(x_83, 3, x_82);
-lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_76);
-x_84 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_84, 0, x_1);
-lean_ctor_set(x_84, 1, x_2);
-lean_ctor_set(x_84, 2, x_3);
-lean_ctor_set(x_84, 3, x_83);
-lean_ctor_set_uint8(x_84, sizeof(void*)*4, x_76);
-return x_84;
-}
-}
-else
-{
-uint8_t x_85; 
-x_85 = !lean_is_exclusive(x_1);
-if (x_85 == 0)
-{
-uint8_t x_86; 
-x_86 = !lean_is_exclusive(x_4);
-if (x_86 == 0)
-{
-lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; 
-x_87 = lean_ctor_get(x_1, 0);
-x_88 = lean_ctor_get(x_1, 1);
-x_89 = lean_ctor_get(x_1, 2);
-x_90 = lean_ctor_get(x_1, 3);
-x_91 = lean_ctor_get(x_4, 1);
-x_92 = lean_ctor_get(x_4, 2);
-x_93 = lean_ctor_get(x_4, 3);
-x_94 = lean_ctor_get(x_4, 0);
-lean_dec(x_94);
-x_95 = !lean_is_exclusive(x_74);
-if (x_95 == 0)
-{
-lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-x_96 = lean_ctor_get(x_74, 0);
-x_97 = lean_ctor_get(x_74, 1);
-x_98 = lean_ctor_get(x_74, 2);
-x_99 = lean_ctor_get(x_74, 3);
-lean_ctor_set(x_74, 3, x_90);
-lean_ctor_set(x_74, 2, x_89);
-lean_ctor_set(x_74, 1, x_88);
-lean_ctor_set(x_74, 0, x_87);
-lean_ctor_set(x_4, 3, x_96);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_76);
-x_100 = l_Std_RBNode_setRed___rarg(x_93);
-x_101 = l_Std_RBNode_balance_u2083___rarg(x_99, x_91, x_92, x_100);
-lean_ctor_set(x_1, 3, x_101);
-lean_ctor_set(x_1, 2, x_98);
-lean_ctor_set(x_1, 1, x_97);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_73);
-return x_1;
-}
-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; 
-x_102 = lean_ctor_get(x_74, 0);
-x_103 = lean_ctor_get(x_74, 1);
-x_104 = lean_ctor_get(x_74, 2);
-x_105 = lean_ctor_get(x_74, 3);
-lean_inc(x_105);
-lean_inc(x_104);
-lean_inc(x_103);
-lean_inc(x_102);
-lean_dec(x_74);
-x_106 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_106, 0, x_87);
-lean_ctor_set(x_106, 1, x_88);
-lean_ctor_set(x_106, 2, x_89);
-lean_ctor_set(x_106, 3, x_90);
-lean_ctor_set_uint8(x_106, sizeof(void*)*4, x_76);
-lean_ctor_set(x_4, 3, x_102);
-lean_ctor_set(x_4, 2, x_3);
-lean_ctor_set(x_4, 1, x_2);
-lean_ctor_set(x_4, 0, x_106);
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_76);
-x_107 = l_Std_RBNode_setRed___rarg(x_93);
-x_108 = l_Std_RBNode_balance_u2083___rarg(x_105, x_91, x_92, x_107);
-lean_ctor_set(x_1, 3, x_108);
-lean_ctor_set(x_1, 2, x_104);
-lean_ctor_set(x_1, 1, x_103);
-lean_ctor_set(x_1, 0, x_4);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_73);
-return x_1;
-}
-}
-else
-{
-lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; 
-x_109 = lean_ctor_get(x_1, 0);
-x_110 = lean_ctor_get(x_1, 1);
-x_111 = lean_ctor_get(x_1, 2);
-x_112 = lean_ctor_get(x_1, 3);
-x_113 = lean_ctor_get(x_4, 1);
-x_114 = lean_ctor_get(x_4, 2);
-x_115 = lean_ctor_get(x_4, 3);
-lean_inc(x_115);
-lean_inc(x_114);
-lean_inc(x_113);
-lean_dec(x_4);
-x_116 = lean_ctor_get(x_74, 0);
-lean_inc(x_116);
-x_117 = lean_ctor_get(x_74, 1);
-lean_inc(x_117);
-x_118 = lean_ctor_get(x_74, 2);
-lean_inc(x_118);
-x_119 = lean_ctor_get(x_74, 3);
-lean_inc(x_119);
-if (lean_is_exclusive(x_74)) {
- lean_ctor_release(x_74, 0);
- lean_ctor_release(x_74, 1);
- lean_ctor_release(x_74, 2);
- lean_ctor_release(x_74, 3);
- x_120 = x_74;
-} else {
- lean_dec_ref(x_74);
- x_120 = lean_box(0);
-}
-if (lean_is_scalar(x_120)) {
- x_121 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_121 = x_120;
-}
-lean_ctor_set(x_121, 0, x_109);
-lean_ctor_set(x_121, 1, x_110);
-lean_ctor_set(x_121, 2, x_111);
-lean_ctor_set(x_121, 3, x_112);
-lean_ctor_set_uint8(x_121, sizeof(void*)*4, x_76);
-x_122 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_122, 0, x_121);
-lean_ctor_set(x_122, 1, x_2);
-lean_ctor_set(x_122, 2, x_3);
-lean_ctor_set(x_122, 3, x_116);
-lean_ctor_set_uint8(x_122, sizeof(void*)*4, x_76);
-x_123 = l_Std_RBNode_setRed___rarg(x_115);
-x_124 = l_Std_RBNode_balance_u2083___rarg(x_119, x_113, x_114, x_123);
-lean_ctor_set(x_1, 3, x_124);
-lean_ctor_set(x_1, 2, x_118);
-lean_ctor_set(x_1, 1, x_117);
-lean_ctor_set(x_1, 0, x_122);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_73);
-return x_1;
-}
-}
-else
-{
-lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; 
-x_125 = lean_ctor_get(x_1, 0);
-x_126 = lean_ctor_get(x_1, 1);
-x_127 = lean_ctor_get(x_1, 2);
-x_128 = lean_ctor_get(x_1, 3);
-lean_inc(x_128);
-lean_inc(x_127);
-lean_inc(x_126);
-lean_inc(x_125);
-lean_dec(x_1);
-x_129 = lean_ctor_get(x_4, 1);
-lean_inc(x_129);
-x_130 = lean_ctor_get(x_4, 2);
-lean_inc(x_130);
-x_131 = lean_ctor_get(x_4, 3);
-lean_inc(x_131);
-if (lean_is_exclusive(x_4)) {
- lean_ctor_release(x_4, 0);
- lean_ctor_release(x_4, 1);
- lean_ctor_release(x_4, 2);
- lean_ctor_release(x_4, 3);
- x_132 = x_4;
-} else {
- lean_dec_ref(x_4);
- x_132 = lean_box(0);
-}
-x_133 = lean_ctor_get(x_74, 0);
-lean_inc(x_133);
-x_134 = lean_ctor_get(x_74, 1);
-lean_inc(x_134);
-x_135 = lean_ctor_get(x_74, 2);
-lean_inc(x_135);
-x_136 = lean_ctor_get(x_74, 3);
-lean_inc(x_136);
-if (lean_is_exclusive(x_74)) {
- lean_ctor_release(x_74, 0);
- lean_ctor_release(x_74, 1);
- lean_ctor_release(x_74, 2);
- lean_ctor_release(x_74, 3);
- x_137 = x_74;
-} else {
- lean_dec_ref(x_74);
- x_137 = lean_box(0);
-}
-if (lean_is_scalar(x_137)) {
- x_138 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_138 = x_137;
-}
-lean_ctor_set(x_138, 0, x_125);
-lean_ctor_set(x_138, 1, x_126);
-lean_ctor_set(x_138, 2, x_127);
-lean_ctor_set(x_138, 3, x_128);
-lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_76);
-if (lean_is_scalar(x_132)) {
- x_139 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_139 = x_132;
-}
-lean_ctor_set(x_139, 0, x_138);
-lean_ctor_set(x_139, 1, x_2);
-lean_ctor_set(x_139, 2, x_3);
-lean_ctor_set(x_139, 3, x_133);
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_76);
-x_140 = l_Std_RBNode_setRed___rarg(x_131);
-x_141 = l_Std_RBNode_balance_u2083___rarg(x_136, x_129, x_130, x_140);
-x_142 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_142, 0, x_139);
-lean_ctor_set(x_142, 1, x_134);
-lean_ctor_set(x_142, 2, x_135);
-lean_ctor_set(x_142, 3, x_141);
-lean_ctor_set_uint8(x_142, sizeof(void*)*4, x_73);
-return x_142;
-}
-}
-}
-}
-else
-{
-uint8_t x_143; 
-x_143 = !lean_is_exclusive(x_1);
-if (x_143 == 0)
-{
-uint8_t x_144; 
-x_144 = !lean_is_exclusive(x_4);
-if (x_144 == 0)
-{
-lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; uint8_t x_153; lean_object* x_154; 
-x_145 = lean_ctor_get(x_1, 0);
-x_146 = lean_ctor_get(x_1, 1);
-x_147 = lean_ctor_get(x_1, 2);
-x_148 = lean_ctor_get(x_1, 3);
-x_149 = lean_ctor_get(x_4, 0);
-x_150 = lean_ctor_get(x_4, 1);
-x_151 = lean_ctor_get(x_4, 2);
-x_152 = lean_ctor_get(x_4, 3);
-lean_ctor_set(x_4, 3, x_148);
-lean_ctor_set(x_4, 2, x_147);
-lean_ctor_set(x_4, 1, x_146);
-lean_ctor_set(x_4, 0, x_145);
-x_153 = 0;
-lean_ctor_set(x_1, 3, x_152);
-lean_ctor_set(x_1, 2, x_151);
-lean_ctor_set(x_1, 1, x_150);
-lean_ctor_set(x_1, 0, x_149);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_153);
-x_154 = l_Std_RBNode_balance_u2083___rarg(x_4, x_2, x_3, x_1);
-return x_154;
-}
-else
-{
-lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; uint8_t x_164; lean_object* x_165; 
-x_155 = lean_ctor_get(x_1, 0);
-x_156 = lean_ctor_get(x_1, 1);
-x_157 = lean_ctor_get(x_1, 2);
-x_158 = lean_ctor_get(x_1, 3);
-x_159 = lean_ctor_get(x_4, 0);
-x_160 = lean_ctor_get(x_4, 1);
-x_161 = lean_ctor_get(x_4, 2);
-x_162 = lean_ctor_get(x_4, 3);
-lean_inc(x_162);
-lean_inc(x_161);
-lean_inc(x_160);
-lean_inc(x_159);
-lean_dec(x_4);
-x_163 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_163, 0, x_155);
-lean_ctor_set(x_163, 1, x_156);
-lean_ctor_set(x_163, 2, x_157);
-lean_ctor_set(x_163, 3, x_158);
-lean_ctor_set_uint8(x_163, sizeof(void*)*4, x_73);
-x_164 = 0;
-lean_ctor_set(x_1, 3, x_162);
-lean_ctor_set(x_1, 2, x_161);
-lean_ctor_set(x_1, 1, x_160);
-lean_ctor_set(x_1, 0, x_159);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_164);
-x_165 = l_Std_RBNode_balance_u2083___rarg(x_163, x_2, x_3, x_1);
-return x_165;
-}
-}
-else
-{
-lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; uint8_t x_176; lean_object* x_177; lean_object* x_178; 
-x_166 = lean_ctor_get(x_1, 0);
-x_167 = lean_ctor_get(x_1, 1);
-x_168 = lean_ctor_get(x_1, 2);
-x_169 = lean_ctor_get(x_1, 3);
-lean_inc(x_169);
-lean_inc(x_168);
-lean_inc(x_167);
+lean_object* x_166; 
+x_166 = lean_ctor_get(x_4, 0);
 lean_inc(x_166);
+if (lean_obj_tag(x_166) == 0)
+{
+uint8_t x_167; lean_object* x_168; 
+x_167 = 0;
+x_168 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_168, 0, x_1);
+lean_ctor_set(x_168, 1, x_2);
+lean_ctor_set(x_168, 2, x_3);
+lean_ctor_set(x_168, 3, x_4);
+lean_ctor_set_uint8(x_168, sizeof(void*)*4, x_167);
+return x_168;
+}
+else
+{
+uint8_t x_169; 
+x_169 = lean_ctor_get_uint8(x_166, sizeof(void*)*4);
+if (x_169 == 0)
+{
+uint8_t x_170; 
+x_170 = !lean_is_exclusive(x_4);
+if (x_170 == 0)
+{
+lean_object* x_171; uint8_t x_172; lean_object* x_173; 
+x_171 = lean_ctor_get(x_4, 0);
+lean_dec(x_171);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_169);
+x_172 = 0;
+x_173 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_173, 0, x_1);
+lean_ctor_set(x_173, 1, x_2);
+lean_ctor_set(x_173, 2, x_3);
+lean_ctor_set(x_173, 3, x_4);
+lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
+return x_173;
+}
+else
+{
+lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; lean_object* x_179; 
+x_174 = lean_ctor_get(x_4, 1);
+x_175 = lean_ctor_get(x_4, 2);
+x_176 = lean_ctor_get(x_4, 3);
+lean_inc(x_176);
+lean_inc(x_175);
+lean_inc(x_174);
+lean_dec(x_4);
+x_177 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_177, 0, x_166);
+lean_ctor_set(x_177, 1, x_174);
+lean_ctor_set(x_177, 2, x_175);
+lean_ctor_set(x_177, 3, x_176);
+lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_169);
+x_178 = 0;
+x_179 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_179, 0, x_1);
+lean_ctor_set(x_179, 1, x_2);
+lean_ctor_set(x_179, 2, x_3);
+lean_ctor_set(x_179, 3, x_177);
+lean_ctor_set_uint8(x_179, sizeof(void*)*4, x_178);
+return x_179;
+}
+}
+else
+{
+uint8_t x_180; 
+x_180 = !lean_is_exclusive(x_1);
+if (x_180 == 0)
+{
+uint8_t x_181; 
+x_181 = !lean_is_exclusive(x_4);
+if (x_181 == 0)
+{
+lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; uint8_t x_190; 
+x_182 = lean_ctor_get(x_1, 0);
+x_183 = lean_ctor_get(x_1, 1);
+x_184 = lean_ctor_get(x_1, 2);
+x_185 = lean_ctor_get(x_1, 3);
+x_186 = lean_ctor_get(x_4, 1);
+x_187 = lean_ctor_get(x_4, 2);
+x_188 = lean_ctor_get(x_4, 3);
+x_189 = lean_ctor_get(x_4, 0);
+lean_dec(x_189);
+x_190 = !lean_is_exclusive(x_166);
+if (x_190 == 0)
+{
+lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; uint8_t x_195; lean_object* x_196; lean_object* x_197; uint8_t x_198; 
+x_191 = lean_ctor_get(x_166, 0);
+x_192 = lean_ctor_get(x_166, 1);
+x_193 = lean_ctor_get(x_166, 2);
+x_194 = lean_ctor_get(x_166, 3);
+lean_ctor_set(x_166, 3, x_185);
+lean_ctor_set(x_166, 2, x_184);
+lean_ctor_set(x_166, 1, x_183);
+lean_ctor_set(x_166, 0, x_182);
+x_195 = 1;
+lean_ctor_set(x_4, 3, x_191);
+lean_ctor_set(x_4, 2, x_3);
+lean_ctor_set(x_4, 1, x_2);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_195);
+x_196 = l_Std_RBNode_setRed___rarg(x_188);
+x_197 = l_Std_RBNode_balance_u2083___rarg(x_194, x_186, x_187, x_196);
+x_198 = 0;
+lean_ctor_set(x_1, 3, x_197);
+lean_ctor_set(x_1, 2, x_193);
+lean_ctor_set(x_1, 1, x_192);
+lean_ctor_set(x_1, 0, x_4);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_198);
+return x_1;
+}
+else
+{
+lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; uint8_t x_204; lean_object* x_205; lean_object* x_206; uint8_t x_207; 
+x_199 = lean_ctor_get(x_166, 0);
+x_200 = lean_ctor_get(x_166, 1);
+x_201 = lean_ctor_get(x_166, 2);
+x_202 = lean_ctor_get(x_166, 3);
+lean_inc(x_202);
+lean_inc(x_201);
+lean_inc(x_200);
+lean_inc(x_199);
+lean_dec(x_166);
+x_203 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_203, 0, x_182);
+lean_ctor_set(x_203, 1, x_183);
+lean_ctor_set(x_203, 2, x_184);
+lean_ctor_set(x_203, 3, x_185);
+lean_ctor_set_uint8(x_203, sizeof(void*)*4, x_169);
+x_204 = 1;
+lean_ctor_set(x_4, 3, x_199);
+lean_ctor_set(x_4, 2, x_3);
+lean_ctor_set(x_4, 1, x_2);
+lean_ctor_set(x_4, 0, x_203);
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_204);
+x_205 = l_Std_RBNode_setRed___rarg(x_188);
+x_206 = l_Std_RBNode_balance_u2083___rarg(x_202, x_186, x_187, x_205);
+x_207 = 0;
+lean_ctor_set(x_1, 3, x_206);
+lean_ctor_set(x_1, 2, x_201);
+lean_ctor_set(x_1, 1, x_200);
+lean_ctor_set(x_1, 0, x_4);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_207);
+return x_1;
+}
+}
+else
+{
+lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; uint8_t x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; 
+x_208 = lean_ctor_get(x_1, 0);
+x_209 = lean_ctor_get(x_1, 1);
+x_210 = lean_ctor_get(x_1, 2);
+x_211 = lean_ctor_get(x_1, 3);
+x_212 = lean_ctor_get(x_4, 1);
+x_213 = lean_ctor_get(x_4, 2);
+x_214 = lean_ctor_get(x_4, 3);
+lean_inc(x_214);
+lean_inc(x_213);
+lean_inc(x_212);
+lean_dec(x_4);
+x_215 = lean_ctor_get(x_166, 0);
+lean_inc(x_215);
+x_216 = lean_ctor_get(x_166, 1);
+lean_inc(x_216);
+x_217 = lean_ctor_get(x_166, 2);
+lean_inc(x_217);
+x_218 = lean_ctor_get(x_166, 3);
+lean_inc(x_218);
+if (lean_is_exclusive(x_166)) {
+ lean_ctor_release(x_166, 0);
+ lean_ctor_release(x_166, 1);
+ lean_ctor_release(x_166, 2);
+ lean_ctor_release(x_166, 3);
+ x_219 = x_166;
+} else {
+ lean_dec_ref(x_166);
+ x_219 = lean_box(0);
+}
+if (lean_is_scalar(x_219)) {
+ x_220 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_220 = x_219;
+}
+lean_ctor_set(x_220, 0, x_208);
+lean_ctor_set(x_220, 1, x_209);
+lean_ctor_set(x_220, 2, x_210);
+lean_ctor_set(x_220, 3, x_211);
+lean_ctor_set_uint8(x_220, sizeof(void*)*4, x_169);
+x_221 = 1;
+x_222 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_222, 0, x_220);
+lean_ctor_set(x_222, 1, x_2);
+lean_ctor_set(x_222, 2, x_3);
+lean_ctor_set(x_222, 3, x_215);
+lean_ctor_set_uint8(x_222, sizeof(void*)*4, x_221);
+x_223 = l_Std_RBNode_setRed___rarg(x_214);
+x_224 = l_Std_RBNode_balance_u2083___rarg(x_218, x_212, x_213, x_223);
+x_225 = 0;
+lean_ctor_set(x_1, 3, x_224);
+lean_ctor_set(x_1, 2, x_217);
+lean_ctor_set(x_1, 1, x_216);
+lean_ctor_set(x_1, 0, x_222);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_225);
+return x_1;
+}
+}
+else
+{
+lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; uint8_t x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; uint8_t x_244; lean_object* x_245; 
+x_226 = lean_ctor_get(x_1, 0);
+x_227 = lean_ctor_get(x_1, 1);
+x_228 = lean_ctor_get(x_1, 2);
+x_229 = lean_ctor_get(x_1, 3);
+lean_inc(x_229);
+lean_inc(x_228);
+lean_inc(x_227);
+lean_inc(x_226);
 lean_dec(x_1);
-x_170 = lean_ctor_get(x_4, 0);
-lean_inc(x_170);
-x_171 = lean_ctor_get(x_4, 1);
-lean_inc(x_171);
-x_172 = lean_ctor_get(x_4, 2);
-lean_inc(x_172);
-x_173 = lean_ctor_get(x_4, 3);
-lean_inc(x_173);
+x_230 = lean_ctor_get(x_4, 1);
+lean_inc(x_230);
+x_231 = lean_ctor_get(x_4, 2);
+lean_inc(x_231);
+x_232 = lean_ctor_get(x_4, 3);
+lean_inc(x_232);
 if (lean_is_exclusive(x_4)) {
  lean_ctor_release(x_4, 0);
  lean_ctor_release(x_4, 1);
  lean_ctor_release(x_4, 2);
  lean_ctor_release(x_4, 3);
- x_174 = x_4;
+ x_233 = x_4;
 } else {
  lean_dec_ref(x_4);
- x_174 = lean_box(0);
+ x_233 = lean_box(0);
 }
-if (lean_is_scalar(x_174)) {
- x_175 = lean_alloc_ctor(1, 4, 1);
+x_234 = lean_ctor_get(x_166, 0);
+lean_inc(x_234);
+x_235 = lean_ctor_get(x_166, 1);
+lean_inc(x_235);
+x_236 = lean_ctor_get(x_166, 2);
+lean_inc(x_236);
+x_237 = lean_ctor_get(x_166, 3);
+lean_inc(x_237);
+if (lean_is_exclusive(x_166)) {
+ lean_ctor_release(x_166, 0);
+ lean_ctor_release(x_166, 1);
+ lean_ctor_release(x_166, 2);
+ lean_ctor_release(x_166, 3);
+ x_238 = x_166;
 } else {
- x_175 = x_174;
+ lean_dec_ref(x_166);
+ x_238 = lean_box(0);
 }
-lean_ctor_set(x_175, 0, x_166);
-lean_ctor_set(x_175, 1, x_167);
-lean_ctor_set(x_175, 2, x_168);
-lean_ctor_set(x_175, 3, x_169);
-lean_ctor_set_uint8(x_175, sizeof(void*)*4, x_73);
-x_176 = 0;
-x_177 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_177, 0, x_170);
-lean_ctor_set(x_177, 1, x_171);
-lean_ctor_set(x_177, 2, x_172);
-lean_ctor_set(x_177, 3, x_173);
-lean_ctor_set_uint8(x_177, sizeof(void*)*4, x_176);
-x_178 = l_Std_RBNode_balance_u2083___rarg(x_175, x_2, x_3, x_177);
-return x_178;
+if (lean_is_scalar(x_238)) {
+ x_239 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_239 = x_238;
+}
+lean_ctor_set(x_239, 0, x_226);
+lean_ctor_set(x_239, 1, x_227);
+lean_ctor_set(x_239, 2, x_228);
+lean_ctor_set(x_239, 3, x_229);
+lean_ctor_set_uint8(x_239, sizeof(void*)*4, x_169);
+x_240 = 1;
+if (lean_is_scalar(x_233)) {
+ x_241 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_241 = x_233;
+}
+lean_ctor_set(x_241, 0, x_239);
+lean_ctor_set(x_241, 1, x_2);
+lean_ctor_set(x_241, 2, x_3);
+lean_ctor_set(x_241, 3, x_234);
+lean_ctor_set_uint8(x_241, sizeof(void*)*4, x_240);
+x_242 = l_Std_RBNode_setRed___rarg(x_232);
+x_243 = l_Std_RBNode_balance_u2083___rarg(x_237, x_230, x_231, x_242);
+x_244 = 0;
+x_245 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_245, 0, x_241);
+lean_ctor_set(x_245, 1, x_235);
+lean_ctor_set(x_245, 2, x_236);
+lean_ctor_set(x_245, 3, x_243);
+lean_ctor_set_uint8(x_245, sizeof(void*)*4, x_244);
+return x_245;
+}
+}
+}
+}
+else
+{
+uint8_t x_246; 
+x_246 = !lean_is_exclusive(x_1);
+if (x_246 == 0)
+{
+uint8_t x_247; 
+x_247 = !lean_is_exclusive(x_4);
+if (x_247 == 0)
+{
+lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; uint8_t x_256; lean_object* x_257; 
+x_248 = lean_ctor_get(x_1, 0);
+x_249 = lean_ctor_get(x_1, 1);
+x_250 = lean_ctor_get(x_1, 2);
+x_251 = lean_ctor_get(x_1, 3);
+x_252 = lean_ctor_get(x_4, 0);
+x_253 = lean_ctor_get(x_4, 1);
+x_254 = lean_ctor_get(x_4, 2);
+x_255 = lean_ctor_get(x_4, 3);
+lean_ctor_set(x_4, 3, x_251);
+lean_ctor_set(x_4, 2, x_250);
+lean_ctor_set(x_4, 1, x_249);
+lean_ctor_set(x_4, 0, x_248);
+x_256 = 0;
+lean_ctor_set(x_1, 3, x_255);
+lean_ctor_set(x_1, 2, x_254);
+lean_ctor_set(x_1, 1, x_253);
+lean_ctor_set(x_1, 0, x_252);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_256);
+x_257 = l_Std_RBNode_balance_u2083___rarg(x_4, x_2, x_3, x_1);
+return x_257;
+}
+else
+{
+lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; lean_object* x_262; lean_object* x_263; lean_object* x_264; lean_object* x_265; lean_object* x_266; uint8_t x_267; lean_object* x_268; 
+x_258 = lean_ctor_get(x_1, 0);
+x_259 = lean_ctor_get(x_1, 1);
+x_260 = lean_ctor_get(x_1, 2);
+x_261 = lean_ctor_get(x_1, 3);
+x_262 = lean_ctor_get(x_4, 0);
+x_263 = lean_ctor_get(x_4, 1);
+x_264 = lean_ctor_get(x_4, 2);
+x_265 = lean_ctor_get(x_4, 3);
+lean_inc(x_265);
+lean_inc(x_264);
+lean_inc(x_263);
+lean_inc(x_262);
+lean_dec(x_4);
+x_266 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_266, 0, x_258);
+lean_ctor_set(x_266, 1, x_259);
+lean_ctor_set(x_266, 2, x_260);
+lean_ctor_set(x_266, 3, x_261);
+lean_ctor_set_uint8(x_266, sizeof(void*)*4, x_165);
+x_267 = 0;
+lean_ctor_set(x_1, 3, x_265);
+lean_ctor_set(x_1, 2, x_264);
+lean_ctor_set(x_1, 1, x_263);
+lean_ctor_set(x_1, 0, x_262);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_267);
+x_268 = l_Std_RBNode_balance_u2083___rarg(x_266, x_2, x_3, x_1);
+return x_268;
+}
+}
+else
+{
+lean_object* x_269; lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; uint8_t x_279; lean_object* x_280; lean_object* x_281; 
+x_269 = lean_ctor_get(x_1, 0);
+x_270 = lean_ctor_get(x_1, 1);
+x_271 = lean_ctor_get(x_1, 2);
+x_272 = lean_ctor_get(x_1, 3);
+lean_inc(x_272);
+lean_inc(x_271);
+lean_inc(x_270);
+lean_inc(x_269);
+lean_dec(x_1);
+x_273 = lean_ctor_get(x_4, 0);
+lean_inc(x_273);
+x_274 = lean_ctor_get(x_4, 1);
+lean_inc(x_274);
+x_275 = lean_ctor_get(x_4, 2);
+lean_inc(x_275);
+x_276 = lean_ctor_get(x_4, 3);
+lean_inc(x_276);
+if (lean_is_exclusive(x_4)) {
+ lean_ctor_release(x_4, 0);
+ lean_ctor_release(x_4, 1);
+ lean_ctor_release(x_4, 2);
+ lean_ctor_release(x_4, 3);
+ x_277 = x_4;
+} else {
+ lean_dec_ref(x_4);
+ x_277 = lean_box(0);
+}
+if (lean_is_scalar(x_277)) {
+ x_278 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_278 = x_277;
+}
+lean_ctor_set(x_278, 0, x_269);
+lean_ctor_set(x_278, 1, x_270);
+lean_ctor_set(x_278, 2, x_271);
+lean_ctor_set(x_278, 3, x_272);
+lean_ctor_set_uint8(x_278, sizeof(void*)*4, x_165);
+x_279 = 0;
+x_280 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_280, 0, x_273);
+lean_ctor_set(x_280, 1, x_274);
+lean_ctor_set(x_280, 2, x_275);
+lean_ctor_set(x_280, 3, x_276);
+lean_ctor_set_uint8(x_280, sizeof(void*)*4, x_279);
+x_281 = l_Std_RBNode_balance_u2083___rarg(x_278, x_2, x_3, x_280);
+return x_281;
 }
 }
 }
@@ -20992,6 +17591,173 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_balLeft___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBNode_balRight_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_3);
+lean_dec(x_2);
+x_5 = lean_apply_1(x_4, x_1);
+return x_5;
+}
+else
+{
+uint8_t x_6; 
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_6 == 0)
+{
+lean_object* x_7; 
+lean_dec(x_2);
+x_7 = lean_ctor_get(x_1, 3);
+lean_inc(x_7);
+if (lean_obj_tag(x_7) == 0)
+{
+lean_object* x_8; 
+lean_dec(x_3);
+x_8 = lean_apply_1(x_4, x_1);
+return x_8;
+}
+else
+{
+uint8_t x_9; 
+x_9 = lean_ctor_get_uint8(x_7, sizeof(void*)*4);
+if (x_9 == 0)
+{
+uint8_t x_10; 
+lean_dec(x_3);
+x_10 = !lean_is_exclusive(x_1);
+if (x_10 == 0)
+{
+lean_object* x_11; lean_object* x_12; 
+x_11 = lean_ctor_get(x_1, 3);
+lean_dec(x_11);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_9);
+x_12 = lean_apply_1(x_4, x_1);
+return x_12;
+}
+else
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; 
+x_13 = lean_ctor_get(x_1, 0);
+x_14 = lean_ctor_get(x_1, 1);
+x_15 = lean_ctor_get(x_1, 2);
+lean_inc(x_15);
+lean_inc(x_14);
+lean_inc(x_13);
+lean_dec(x_1);
+x_16 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_16, 0, x_13);
+lean_ctor_set(x_16, 1, x_14);
+lean_ctor_set(x_16, 2, x_15);
+lean_ctor_set(x_16, 3, x_7);
+lean_ctor_set_uint8(x_16, sizeof(void*)*4, x_9);
+x_17 = lean_apply_1(x_4, x_16);
+return x_17;
+}
+}
+else
+{
+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_dec(x_4);
+x_18 = lean_ctor_get(x_1, 0);
+lean_inc(x_18);
+x_19 = lean_ctor_get(x_1, 1);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_1, 2);
+lean_inc(x_20);
+lean_dec(x_1);
+x_21 = lean_ctor_get(x_7, 0);
+lean_inc(x_21);
+x_22 = lean_ctor_get(x_7, 1);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_7, 2);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_7, 3);
+lean_inc(x_24);
+lean_dec(x_7);
+x_25 = lean_apply_7(x_3, x_18, x_19, x_20, x_21, x_22, x_23, x_24);
+return x_25;
+}
+}
+}
+else
+{
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; 
+lean_dec(x_4);
+lean_dec(x_3);
+x_26 = lean_ctor_get(x_1, 0);
+lean_inc(x_26);
+x_27 = lean_ctor_get(x_1, 1);
+lean_inc(x_27);
+x_28 = lean_ctor_get(x_1, 2);
+lean_inc(x_28);
+x_29 = lean_ctor_get(x_1, 3);
+lean_inc(x_29);
+lean_dec(x_1);
+x_30 = lean_apply_4(x_2, x_26, x_27, x_28, x_29);
+return x_30;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_balRight_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_balRight_match__1___rarg), 4, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_balRight_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 2);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 3);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_apply_4(x_2, x_6, x_7, x_8, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_2);
+x_11 = lean_apply_1(x_3, x_1);
+return x_11;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_balRight_match__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_balRight_match__2___rarg), 3, 0);
+return x_4;
+}
+}
 lean_object* l_Std_RBNode_balRight___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -21020,462 +17786,490 @@ x_8 = lean_ctor_get(x_1, 3);
 lean_inc(x_8);
 if (lean_obj_tag(x_8) == 0)
 {
-lean_object* x_9; 
-x_9 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_9, 0, x_1);
-lean_ctor_set(x_9, 1, x_2);
-lean_ctor_set(x_9, 2, x_3);
-lean_ctor_set(x_9, 3, x_4);
-lean_ctor_set_uint8(x_9, sizeof(void*)*4, x_7);
-return x_9;
+uint8_t x_9; lean_object* x_10; 
+x_9 = 0;
+x_10 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_10, 0, x_1);
+lean_ctor_set(x_10, 1, x_2);
+lean_ctor_set(x_10, 2, x_3);
+lean_ctor_set(x_10, 3, x_4);
+lean_ctor_set_uint8(x_10, sizeof(void*)*4, x_9);
+return x_10;
 }
 else
 {
-uint8_t x_10; 
-x_10 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
-if (x_10 == 0)
-{
 uint8_t x_11; 
-x_11 = !lean_is_exclusive(x_8);
+x_11 = lean_ctor_get_uint8(x_8, sizeof(void*)*4);
 if (x_11 == 0)
 {
-lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; 
-x_12 = lean_ctor_get(x_8, 3);
-lean_dec(x_12);
-x_13 = lean_ctor_get(x_8, 2);
+uint8_t x_12; 
+x_12 = !lean_is_exclusive(x_8);
+if (x_12 == 0)
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; 
+x_13 = lean_ctor_get(x_8, 3);
 lean_dec(x_13);
-x_14 = lean_ctor_get(x_8, 1);
+x_14 = lean_ctor_get(x_8, 2);
 lean_dec(x_14);
-x_15 = lean_ctor_get(x_8, 0);
+x_15 = lean_ctor_get(x_8, 1);
 lean_dec(x_15);
+x_16 = lean_ctor_get(x_8, 0);
+lean_dec(x_16);
+x_17 = 0;
 lean_ctor_set(x_8, 3, x_4);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
 lean_ctor_set(x_8, 0, x_1);
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_17);
 return x_8;
 }
 else
 {
-lean_object* x_16; 
+uint8_t x_18; lean_object* x_19; 
 lean_dec(x_8);
-x_16 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_16, 0, x_1);
-lean_ctor_set(x_16, 1, x_2);
-lean_ctor_set(x_16, 2, x_3);
-lean_ctor_set(x_16, 3, x_4);
-lean_ctor_set_uint8(x_16, sizeof(void*)*4, x_10);
-return x_16;
+x_18 = 0;
+x_19 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_19, 0, x_1);
+lean_ctor_set(x_19, 1, x_2);
+lean_ctor_set(x_19, 2, x_3);
+lean_ctor_set(x_19, 3, x_4);
+lean_ctor_set_uint8(x_19, sizeof(void*)*4, x_18);
+return x_19;
 }
 }
 else
 {
-uint8_t x_17; 
-x_17 = !lean_is_exclusive(x_1);
-if (x_17 == 0)
+uint8_t x_20; 
+x_20 = !lean_is_exclusive(x_1);
+if (x_20 == 0)
 {
-lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; 
-x_18 = lean_ctor_get(x_1, 0);
-x_19 = lean_ctor_get(x_1, 1);
-x_20 = lean_ctor_get(x_1, 2);
-x_21 = lean_ctor_get(x_1, 3);
-lean_dec(x_21);
-x_22 = !lean_is_exclusive(x_8);
-if (x_22 == 0)
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; 
+x_21 = lean_ctor_get(x_1, 0);
+x_22 = lean_ctor_get(x_1, 1);
+x_23 = lean_ctor_get(x_1, 2);
+x_24 = lean_ctor_get(x_1, 3);
+lean_dec(x_24);
+x_25 = !lean_is_exclusive(x_8);
+if (x_25 == 0)
 {
-lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; 
-x_23 = lean_ctor_get(x_8, 0);
-x_24 = lean_ctor_get(x_8, 1);
-x_25 = lean_ctor_get(x_8, 2);
-x_26 = lean_ctor_get(x_8, 3);
-x_27 = l_Std_RBNode_setRed___rarg(x_18);
-x_28 = l_Std_RBNode_balance_u2083___rarg(x_27, x_19, x_20, x_23);
+lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; uint8_t x_33; 
+x_26 = lean_ctor_get(x_8, 0);
+x_27 = lean_ctor_get(x_8, 1);
+x_28 = lean_ctor_get(x_8, 2);
+x_29 = lean_ctor_get(x_8, 3);
+x_30 = l_Std_RBNode_setRed___rarg(x_21);
+x_31 = l_Std_RBNode_balance_u2083___rarg(x_30, x_22, x_23, x_26);
+x_32 = 1;
 lean_ctor_set(x_8, 3, x_4);
 lean_ctor_set(x_8, 2, x_3);
 lean_ctor_set(x_8, 1, x_2);
-lean_ctor_set(x_8, 0, x_26);
-lean_ctor_set(x_1, 2, x_25);
-lean_ctor_set(x_1, 1, x_24);
-lean_ctor_set(x_1, 0, x_28);
+lean_ctor_set(x_8, 0, x_29);
+lean_ctor_set_uint8(x_8, sizeof(void*)*4, x_32);
+x_33 = 0;
+lean_ctor_set(x_1, 2, x_28);
+lean_ctor_set(x_1, 1, x_27);
+lean_ctor_set(x_1, 0, x_31);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_33);
 return x_1;
 }
 else
 {
-lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; 
-x_29 = lean_ctor_get(x_8, 0);
-x_30 = lean_ctor_get(x_8, 1);
-x_31 = lean_ctor_get(x_8, 2);
-x_32 = lean_ctor_get(x_8, 3);
-lean_inc(x_32);
-lean_inc(x_31);
-lean_inc(x_30);
-lean_inc(x_29);
-lean_dec(x_8);
-x_33 = l_Std_RBNode_setRed___rarg(x_18);
-x_34 = l_Std_RBNode_balance_u2083___rarg(x_33, x_19, x_20, x_29);
-x_35 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_35, 0, x_32);
-lean_ctor_set(x_35, 1, x_2);
-lean_ctor_set(x_35, 2, x_3);
-lean_ctor_set(x_35, 3, x_4);
-lean_ctor_set_uint8(x_35, sizeof(void*)*4, x_10);
-lean_ctor_set(x_1, 3, x_35);
-lean_ctor_set(x_1, 2, x_31);
-lean_ctor_set(x_1, 1, x_30);
-lean_ctor_set(x_1, 0, x_34);
-return x_1;
-}
-}
-else
-{
-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; 
-x_36 = lean_ctor_get(x_1, 0);
-x_37 = lean_ctor_get(x_1, 1);
-x_38 = lean_ctor_get(x_1, 2);
-lean_inc(x_38);
+lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; uint8_t x_42; 
+x_34 = lean_ctor_get(x_8, 0);
+x_35 = lean_ctor_get(x_8, 1);
+x_36 = lean_ctor_get(x_8, 2);
+x_37 = lean_ctor_get(x_8, 3);
 lean_inc(x_37);
 lean_inc(x_36);
+lean_inc(x_35);
+lean_inc(x_34);
+lean_dec(x_8);
+x_38 = l_Std_RBNode_setRed___rarg(x_21);
+x_39 = l_Std_RBNode_balance_u2083___rarg(x_38, x_22, x_23, x_34);
+x_40 = 1;
+x_41 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_41, 0, x_37);
+lean_ctor_set(x_41, 1, x_2);
+lean_ctor_set(x_41, 2, x_3);
+lean_ctor_set(x_41, 3, x_4);
+lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_40);
+x_42 = 0;
+lean_ctor_set(x_1, 3, x_41);
+lean_ctor_set(x_1, 2, x_36);
+lean_ctor_set(x_1, 1, x_35);
+lean_ctor_set(x_1, 0, x_39);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_42);
+return x_1;
+}
+}
+else
+{
+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; uint8_t x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; 
+x_43 = lean_ctor_get(x_1, 0);
+x_44 = lean_ctor_get(x_1, 1);
+x_45 = lean_ctor_get(x_1, 2);
+lean_inc(x_45);
+lean_inc(x_44);
+lean_inc(x_43);
 lean_dec(x_1);
-x_39 = lean_ctor_get(x_8, 0);
-lean_inc(x_39);
-x_40 = lean_ctor_get(x_8, 1);
-lean_inc(x_40);
-x_41 = lean_ctor_get(x_8, 2);
-lean_inc(x_41);
-x_42 = lean_ctor_get(x_8, 3);
-lean_inc(x_42);
+x_46 = lean_ctor_get(x_8, 0);
+lean_inc(x_46);
+x_47 = lean_ctor_get(x_8, 1);
+lean_inc(x_47);
+x_48 = lean_ctor_get(x_8, 2);
+lean_inc(x_48);
+x_49 = lean_ctor_get(x_8, 3);
+lean_inc(x_49);
 if (lean_is_exclusive(x_8)) {
  lean_ctor_release(x_8, 0);
  lean_ctor_release(x_8, 1);
  lean_ctor_release(x_8, 2);
  lean_ctor_release(x_8, 3);
- x_43 = x_8;
+ x_50 = x_8;
 } else {
  lean_dec_ref(x_8);
- x_43 = lean_box(0);
+ x_50 = lean_box(0);
 }
-x_44 = l_Std_RBNode_setRed___rarg(x_36);
-x_45 = l_Std_RBNode_balance_u2083___rarg(x_44, x_37, x_38, x_39);
-if (lean_is_scalar(x_43)) {
- x_46 = lean_alloc_ctor(1, 4, 1);
+x_51 = l_Std_RBNode_setRed___rarg(x_43);
+x_52 = l_Std_RBNode_balance_u2083___rarg(x_51, x_44, x_45, x_46);
+x_53 = 1;
+if (lean_is_scalar(x_50)) {
+ x_54 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_46 = x_43;
+ x_54 = x_50;
 }
-lean_ctor_set(x_46, 0, x_42);
-lean_ctor_set(x_46, 1, x_2);
-lean_ctor_set(x_46, 2, x_3);
-lean_ctor_set(x_46, 3, x_4);
-lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_10);
-x_47 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_47, 0, x_45);
-lean_ctor_set(x_47, 1, x_40);
-lean_ctor_set(x_47, 2, x_41);
-lean_ctor_set(x_47, 3, x_46);
-lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_7);
-return x_47;
-}
-}
-}
-}
-else
-{
-uint8_t x_48; 
-x_48 = !lean_is_exclusive(x_1);
-if (x_48 == 0)
-{
-uint8_t x_49; lean_object* x_50; 
-x_49 = 0;
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_49);
-x_50 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_4);
-return x_50;
-}
-else
-{
-lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; 
-x_51 = lean_ctor_get(x_1, 0);
-x_52 = lean_ctor_get(x_1, 1);
-x_53 = lean_ctor_get(x_1, 2);
-x_54 = lean_ctor_get(x_1, 3);
-lean_inc(x_54);
-lean_inc(x_53);
-lean_inc(x_52);
-lean_inc(x_51);
-lean_dec(x_1);
+lean_ctor_set(x_54, 0, x_49);
+lean_ctor_set(x_54, 1, x_2);
+lean_ctor_set(x_54, 2, x_3);
+lean_ctor_set(x_54, 3, x_4);
+lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_53);
 x_55 = 0;
 x_56 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_56, 0, x_51);
-lean_ctor_set(x_56, 1, x_52);
-lean_ctor_set(x_56, 2, x_53);
+lean_ctor_set(x_56, 0, x_52);
+lean_ctor_set(x_56, 1, x_47);
+lean_ctor_set(x_56, 2, x_48);
 lean_ctor_set(x_56, 3, x_54);
 lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55);
-x_57 = l_Std_RBNode_balance_u2083___rarg(x_56, x_2, x_3, x_4);
-return x_57;
+return x_56;
 }
 }
 }
 }
 else
 {
-uint8_t x_58; 
-x_58 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
-if (x_58 == 0)
+uint8_t x_57; 
+x_57 = !lean_is_exclusive(x_1);
+if (x_57 == 0)
 {
-uint8_t x_59; 
-x_59 = !lean_is_exclusive(x_4);
-if (x_59 == 0)
-{
-uint8_t x_60; lean_object* x_61; 
-x_60 = 1;
-lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_60);
-x_61 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_61, 0, x_1);
-lean_ctor_set(x_61, 1, x_2);
-lean_ctor_set(x_61, 2, x_3);
-lean_ctor_set(x_61, 3, x_4);
-lean_ctor_set_uint8(x_61, sizeof(void*)*4, x_58);
-return x_61;
+uint8_t x_58; lean_object* x_59; 
+x_58 = 0;
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_58);
+x_59 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_4);
+return x_59;
 }
 else
 {
-lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; lean_object* x_67; lean_object* x_68; 
-x_62 = lean_ctor_get(x_4, 0);
-x_63 = lean_ctor_get(x_4, 1);
-x_64 = lean_ctor_get(x_4, 2);
-x_65 = lean_ctor_get(x_4, 3);
-lean_inc(x_65);
-lean_inc(x_64);
+lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; uint8_t x_64; lean_object* x_65; lean_object* x_66; 
+x_60 = lean_ctor_get(x_1, 0);
+x_61 = lean_ctor_get(x_1, 1);
+x_62 = lean_ctor_get(x_1, 2);
+x_63 = lean_ctor_get(x_1, 3);
 lean_inc(x_63);
 lean_inc(x_62);
+lean_inc(x_61);
+lean_inc(x_60);
+lean_dec(x_1);
+x_64 = 0;
+x_65 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_65, 0, x_60);
+lean_ctor_set(x_65, 1, x_61);
+lean_ctor_set(x_65, 2, x_62);
+lean_ctor_set(x_65, 3, x_63);
+lean_ctor_set_uint8(x_65, sizeof(void*)*4, x_64);
+x_66 = l_Std_RBNode_balance_u2083___rarg(x_65, x_2, x_3, x_4);
+return x_66;
+}
+}
+}
+}
+else
+{
+uint8_t x_67; 
+x_67 = lean_ctor_get_uint8(x_4, sizeof(void*)*4);
+if (x_67 == 0)
+{
+uint8_t x_68; 
+x_68 = !lean_is_exclusive(x_4);
+if (x_68 == 0)
+{
+uint8_t x_69; uint8_t x_70; lean_object* x_71; 
+x_69 = 1;
+lean_ctor_set_uint8(x_4, sizeof(void*)*4, x_69);
+x_70 = 0;
+x_71 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_71, 0, x_1);
+lean_ctor_set(x_71, 1, x_2);
+lean_ctor_set(x_71, 2, x_3);
+lean_ctor_set(x_71, 3, x_4);
+lean_ctor_set_uint8(x_71, sizeof(void*)*4, x_70);
+return x_71;
+}
+else
+{
+lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; 
+x_72 = lean_ctor_get(x_4, 0);
+x_73 = lean_ctor_get(x_4, 1);
+x_74 = lean_ctor_get(x_4, 2);
+x_75 = lean_ctor_get(x_4, 3);
+lean_inc(x_75);
+lean_inc(x_74);
+lean_inc(x_73);
+lean_inc(x_72);
 lean_dec(x_4);
-x_66 = 1;
-x_67 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_67, 0, x_62);
-lean_ctor_set(x_67, 1, x_63);
-lean_ctor_set(x_67, 2, x_64);
-lean_ctor_set(x_67, 3, x_65);
-lean_ctor_set_uint8(x_67, sizeof(void*)*4, x_66);
-x_68 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_68, 0, x_1);
-lean_ctor_set(x_68, 1, x_2);
-lean_ctor_set(x_68, 2, x_3);
-lean_ctor_set(x_68, 3, x_67);
-lean_ctor_set_uint8(x_68, sizeof(void*)*4, x_58);
-return x_68;
+x_76 = 1;
+x_77 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_77, 0, x_72);
+lean_ctor_set(x_77, 1, x_73);
+lean_ctor_set(x_77, 2, x_74);
+lean_ctor_set(x_77, 3, x_75);
+lean_ctor_set_uint8(x_77, sizeof(void*)*4, x_76);
+x_78 = 0;
+x_79 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_79, 0, x_1);
+lean_ctor_set(x_79, 1, x_2);
+lean_ctor_set(x_79, 2, x_3);
+lean_ctor_set(x_79, 3, x_77);
+lean_ctor_set_uint8(x_79, sizeof(void*)*4, x_78);
+return x_79;
 }
 }
 else
 {
 if (lean_obj_tag(x_1) == 0)
 {
-uint8_t x_69; lean_object* x_70; 
-x_69 = 0;
-x_70 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_70, 0, x_1);
-lean_ctor_set(x_70, 1, x_2);
-lean_ctor_set(x_70, 2, x_3);
-lean_ctor_set(x_70, 3, x_4);
-lean_ctor_set_uint8(x_70, sizeof(void*)*4, x_69);
-return x_70;
+uint8_t x_80; lean_object* x_81; 
+x_80 = 0;
+x_81 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_81, 0, x_1);
+lean_ctor_set(x_81, 1, x_2);
+lean_ctor_set(x_81, 2, x_3);
+lean_ctor_set(x_81, 3, x_4);
+lean_ctor_set_uint8(x_81, sizeof(void*)*4, x_80);
+return x_81;
 }
 else
 {
-uint8_t x_71; 
-x_71 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
-if (x_71 == 0)
+uint8_t x_82; 
+x_82 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_82 == 0)
 {
-lean_object* x_72; 
-x_72 = lean_ctor_get(x_1, 3);
-lean_inc(x_72);
-if (lean_obj_tag(x_72) == 0)
+lean_object* x_83; 
+x_83 = lean_ctor_get(x_1, 3);
+lean_inc(x_83);
+if (lean_obj_tag(x_83) == 0)
 {
-lean_object* x_73; 
-x_73 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_73, 0, x_1);
-lean_ctor_set(x_73, 1, x_2);
-lean_ctor_set(x_73, 2, x_3);
-lean_ctor_set(x_73, 3, x_4);
-lean_ctor_set_uint8(x_73, sizeof(void*)*4, x_71);
-return x_73;
+uint8_t x_84; lean_object* x_85; 
+x_84 = 0;
+x_85 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_85, 0, x_1);
+lean_ctor_set(x_85, 1, x_2);
+lean_ctor_set(x_85, 2, x_3);
+lean_ctor_set(x_85, 3, x_4);
+lean_ctor_set_uint8(x_85, sizeof(void*)*4, x_84);
+return x_85;
 }
 else
 {
-uint8_t x_74; 
-x_74 = lean_ctor_get_uint8(x_72, sizeof(void*)*4);
-if (x_74 == 0)
-{
-uint8_t x_75; 
-x_75 = !lean_is_exclusive(x_72);
-if (x_75 == 0)
-{
-lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; 
-x_76 = lean_ctor_get(x_72, 3);
-lean_dec(x_76);
-x_77 = lean_ctor_get(x_72, 2);
-lean_dec(x_77);
-x_78 = lean_ctor_get(x_72, 1);
-lean_dec(x_78);
-x_79 = lean_ctor_get(x_72, 0);
-lean_dec(x_79);
-lean_ctor_set(x_72, 3, x_4);
-lean_ctor_set(x_72, 2, x_3);
-lean_ctor_set(x_72, 1, x_2);
-lean_ctor_set(x_72, 0, x_1);
-return x_72;
-}
-else
-{
-lean_object* x_80; 
-lean_dec(x_72);
-x_80 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_80, 0, x_1);
-lean_ctor_set(x_80, 1, x_2);
-lean_ctor_set(x_80, 2, x_3);
-lean_ctor_set(x_80, 3, x_4);
-lean_ctor_set_uint8(x_80, sizeof(void*)*4, x_74);
-return x_80;
-}
-}
-else
-{
-uint8_t x_81; 
-x_81 = !lean_is_exclusive(x_1);
-if (x_81 == 0)
-{
-lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; 
-x_82 = lean_ctor_get(x_1, 0);
-x_83 = lean_ctor_get(x_1, 1);
-x_84 = lean_ctor_get(x_1, 2);
-x_85 = lean_ctor_get(x_1, 3);
-lean_dec(x_85);
-x_86 = !lean_is_exclusive(x_72);
+uint8_t x_86; 
+x_86 = lean_ctor_get_uint8(x_83, sizeof(void*)*4);
 if (x_86 == 0)
 {
-lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; 
-x_87 = lean_ctor_get(x_72, 0);
-x_88 = lean_ctor_get(x_72, 1);
-x_89 = lean_ctor_get(x_72, 2);
-x_90 = lean_ctor_get(x_72, 3);
-x_91 = l_Std_RBNode_setRed___rarg(x_82);
-x_92 = l_Std_RBNode_balance_u2083___rarg(x_91, x_83, x_84, x_87);
-lean_ctor_set(x_72, 3, x_4);
-lean_ctor_set(x_72, 2, x_3);
-lean_ctor_set(x_72, 1, x_2);
-lean_ctor_set(x_72, 0, x_90);
-lean_ctor_set(x_1, 2, x_89);
-lean_ctor_set(x_1, 1, x_88);
-lean_ctor_set(x_1, 0, x_92);
+uint8_t x_87; 
+x_87 = !lean_is_exclusive(x_83);
+if (x_87 == 0)
+{
+lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; uint8_t x_92; 
+x_88 = lean_ctor_get(x_83, 3);
+lean_dec(x_88);
+x_89 = lean_ctor_get(x_83, 2);
+lean_dec(x_89);
+x_90 = lean_ctor_get(x_83, 1);
+lean_dec(x_90);
+x_91 = lean_ctor_get(x_83, 0);
+lean_dec(x_91);
+x_92 = 0;
+lean_ctor_set(x_83, 3, x_4);
+lean_ctor_set(x_83, 2, x_3);
+lean_ctor_set(x_83, 1, x_2);
+lean_ctor_set(x_83, 0, x_1);
+lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_92);
+return x_83;
+}
+else
+{
+uint8_t x_93; lean_object* x_94; 
+lean_dec(x_83);
+x_93 = 0;
+x_94 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_94, 0, x_1);
+lean_ctor_set(x_94, 1, x_2);
+lean_ctor_set(x_94, 2, x_3);
+lean_ctor_set(x_94, 3, x_4);
+lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_93);
+return x_94;
+}
+}
+else
+{
+uint8_t x_95; 
+x_95 = !lean_is_exclusive(x_1);
+if (x_95 == 0)
+{
+lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; uint8_t x_100; 
+x_96 = lean_ctor_get(x_1, 0);
+x_97 = lean_ctor_get(x_1, 1);
+x_98 = lean_ctor_get(x_1, 2);
+x_99 = lean_ctor_get(x_1, 3);
+lean_dec(x_99);
+x_100 = !lean_is_exclusive(x_83);
+if (x_100 == 0)
+{
+lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; uint8_t x_107; uint8_t x_108; 
+x_101 = lean_ctor_get(x_83, 0);
+x_102 = lean_ctor_get(x_83, 1);
+x_103 = lean_ctor_get(x_83, 2);
+x_104 = lean_ctor_get(x_83, 3);
+x_105 = l_Std_RBNode_setRed___rarg(x_96);
+x_106 = l_Std_RBNode_balance_u2083___rarg(x_105, x_97, x_98, x_101);
+x_107 = 1;
+lean_ctor_set(x_83, 3, x_4);
+lean_ctor_set(x_83, 2, x_3);
+lean_ctor_set(x_83, 1, x_2);
+lean_ctor_set(x_83, 0, x_104);
+lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_107);
+x_108 = 0;
+lean_ctor_set(x_1, 2, x_103);
+lean_ctor_set(x_1, 1, x_102);
+lean_ctor_set(x_1, 0, x_106);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_108);
 return x_1;
 }
 else
 {
-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; 
-x_93 = lean_ctor_get(x_72, 0);
-x_94 = lean_ctor_get(x_72, 1);
-x_95 = lean_ctor_get(x_72, 2);
-x_96 = lean_ctor_get(x_72, 3);
-lean_inc(x_96);
-lean_inc(x_95);
-lean_inc(x_94);
-lean_inc(x_93);
-lean_dec(x_72);
-x_97 = l_Std_RBNode_setRed___rarg(x_82);
-x_98 = l_Std_RBNode_balance_u2083___rarg(x_97, x_83, x_84, x_93);
-x_99 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_99, 0, x_96);
-lean_ctor_set(x_99, 1, x_2);
-lean_ctor_set(x_99, 2, x_3);
-lean_ctor_set(x_99, 3, x_4);
-lean_ctor_set_uint8(x_99, sizeof(void*)*4, x_74);
-lean_ctor_set(x_1, 3, x_99);
-lean_ctor_set(x_1, 2, x_95);
-lean_ctor_set(x_1, 1, x_94);
-lean_ctor_set(x_1, 0, x_98);
+lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; uint8_t x_115; lean_object* x_116; uint8_t x_117; 
+x_109 = lean_ctor_get(x_83, 0);
+x_110 = lean_ctor_get(x_83, 1);
+x_111 = lean_ctor_get(x_83, 2);
+x_112 = lean_ctor_get(x_83, 3);
+lean_inc(x_112);
+lean_inc(x_111);
+lean_inc(x_110);
+lean_inc(x_109);
+lean_dec(x_83);
+x_113 = l_Std_RBNode_setRed___rarg(x_96);
+x_114 = l_Std_RBNode_balance_u2083___rarg(x_113, x_97, x_98, x_109);
+x_115 = 1;
+x_116 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_116, 0, x_112);
+lean_ctor_set(x_116, 1, x_2);
+lean_ctor_set(x_116, 2, x_3);
+lean_ctor_set(x_116, 3, x_4);
+lean_ctor_set_uint8(x_116, sizeof(void*)*4, x_115);
+x_117 = 0;
+lean_ctor_set(x_1, 3, x_116);
+lean_ctor_set(x_1, 2, x_111);
+lean_ctor_set(x_1, 1, x_110);
+lean_ctor_set(x_1, 0, x_114);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_117);
 return x_1;
 }
 }
 else
 {
-lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; 
-x_100 = lean_ctor_get(x_1, 0);
-x_101 = lean_ctor_get(x_1, 1);
-x_102 = lean_ctor_get(x_1, 2);
-lean_inc(x_102);
-lean_inc(x_101);
-lean_inc(x_100);
-lean_dec(x_1);
-x_103 = lean_ctor_get(x_72, 0);
-lean_inc(x_103);
-x_104 = lean_ctor_get(x_72, 1);
-lean_inc(x_104);
-x_105 = lean_ctor_get(x_72, 2);
-lean_inc(x_105);
-x_106 = lean_ctor_get(x_72, 3);
-lean_inc(x_106);
-if (lean_is_exclusive(x_72)) {
- lean_ctor_release(x_72, 0);
- lean_ctor_release(x_72, 1);
- lean_ctor_release(x_72, 2);
- lean_ctor_release(x_72, 3);
- x_107 = x_72;
-} else {
- lean_dec_ref(x_72);
- x_107 = lean_box(0);
-}
-x_108 = l_Std_RBNode_setRed___rarg(x_100);
-x_109 = l_Std_RBNode_balance_u2083___rarg(x_108, x_101, x_102, x_103);
-if (lean_is_scalar(x_107)) {
- x_110 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_110 = x_107;
-}
-lean_ctor_set(x_110, 0, x_106);
-lean_ctor_set(x_110, 1, x_2);
-lean_ctor_set(x_110, 2, x_3);
-lean_ctor_set(x_110, 3, x_4);
-lean_ctor_set_uint8(x_110, sizeof(void*)*4, x_74);
-x_111 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_111, 0, x_109);
-lean_ctor_set(x_111, 1, x_104);
-lean_ctor_set(x_111, 2, x_105);
-lean_ctor_set(x_111, 3, x_110);
-lean_ctor_set_uint8(x_111, sizeof(void*)*4, x_71);
-return x_111;
-}
-}
-}
-}
-else
-{
-uint8_t x_112; 
-x_112 = !lean_is_exclusive(x_1);
-if (x_112 == 0)
-{
-uint8_t x_113; lean_object* x_114; 
-x_113 = 0;
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_113);
-x_114 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_4);
-return x_114;
-}
-else
-{
-lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; uint8_t x_119; lean_object* x_120; lean_object* x_121; 
-x_115 = lean_ctor_get(x_1, 0);
-x_116 = lean_ctor_get(x_1, 1);
-x_117 = lean_ctor_get(x_1, 2);
-x_118 = lean_ctor_get(x_1, 3);
+lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; uint8_t x_128; lean_object* x_129; uint8_t x_130; lean_object* x_131; 
+x_118 = lean_ctor_get(x_1, 0);
+x_119 = lean_ctor_get(x_1, 1);
+x_120 = lean_ctor_get(x_1, 2);
+lean_inc(x_120);
+lean_inc(x_119);
 lean_inc(x_118);
-lean_inc(x_117);
-lean_inc(x_116);
-lean_inc(x_115);
 lean_dec(x_1);
-x_119 = 0;
-x_120 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_120, 0, x_115);
-lean_ctor_set(x_120, 1, x_116);
-lean_ctor_set(x_120, 2, x_117);
-lean_ctor_set(x_120, 3, x_118);
-lean_ctor_set_uint8(x_120, sizeof(void*)*4, x_119);
-x_121 = l_Std_RBNode_balance_u2083___rarg(x_120, x_2, x_3, x_4);
-return x_121;
+x_121 = lean_ctor_get(x_83, 0);
+lean_inc(x_121);
+x_122 = lean_ctor_get(x_83, 1);
+lean_inc(x_122);
+x_123 = lean_ctor_get(x_83, 2);
+lean_inc(x_123);
+x_124 = lean_ctor_get(x_83, 3);
+lean_inc(x_124);
+if (lean_is_exclusive(x_83)) {
+ lean_ctor_release(x_83, 0);
+ lean_ctor_release(x_83, 1);
+ lean_ctor_release(x_83, 2);
+ lean_ctor_release(x_83, 3);
+ x_125 = x_83;
+} else {
+ lean_dec_ref(x_83);
+ x_125 = lean_box(0);
+}
+x_126 = l_Std_RBNode_setRed___rarg(x_118);
+x_127 = l_Std_RBNode_balance_u2083___rarg(x_126, x_119, x_120, x_121);
+x_128 = 1;
+if (lean_is_scalar(x_125)) {
+ x_129 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_129 = x_125;
+}
+lean_ctor_set(x_129, 0, x_124);
+lean_ctor_set(x_129, 1, x_2);
+lean_ctor_set(x_129, 2, x_3);
+lean_ctor_set(x_129, 3, x_4);
+lean_ctor_set_uint8(x_129, sizeof(void*)*4, x_128);
+x_130 = 0;
+x_131 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_131, 0, x_127);
+lean_ctor_set(x_131, 1, x_122);
+lean_ctor_set(x_131, 2, x_123);
+lean_ctor_set(x_131, 3, x_129);
+lean_ctor_set_uint8(x_131, sizeof(void*)*4, x_130);
+return x_131;
+}
+}
+}
+}
+else
+{
+uint8_t x_132; 
+x_132 = !lean_is_exclusive(x_1);
+if (x_132 == 0)
+{
+uint8_t x_133; lean_object* x_134; 
+x_133 = 0;
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_133);
+x_134 = l_Std_RBNode_balance_u2083___rarg(x_1, x_2, x_3, x_4);
+return x_134;
+}
+else
+{
+lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; uint8_t x_139; lean_object* x_140; lean_object* x_141; 
+x_135 = lean_ctor_get(x_1, 0);
+x_136 = lean_ctor_get(x_1, 1);
+x_137 = lean_ctor_get(x_1, 2);
+x_138 = lean_ctor_get(x_1, 3);
+lean_inc(x_138);
+lean_inc(x_137);
+lean_inc(x_136);
+lean_inc(x_135);
+lean_dec(x_1);
+x_139 = 0;
+x_140 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_140, 0, x_135);
+lean_ctor_set(x_140, 1, x_136);
+lean_ctor_set(x_140, 2, x_137);
+lean_ctor_set(x_140, 3, x_138);
+lean_ctor_set_uint8(x_140, sizeof(void*)*4, x_139);
+x_141 = l_Std_RBNode_balance_u2083___rarg(x_140, x_2, x_3, x_4);
+return x_141;
 }
 }
 }
@@ -21491,7 +18285,253 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_balRight___rarg), 4, 0);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_appendTrees___main___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_appendTrees_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 2);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 3);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_apply_4(x_2, x_6, x_7, x_8, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_2);
+x_11 = lean_apply_1(x_3, x_1);
+return x_11;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_appendTrees_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_appendTrees_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_appendTrees_match__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_2);
+x_4 = lean_apply_1(x_3, x_1);
+return x_4;
+}
+else
+{
+uint8_t x_5; 
+x_5 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 2);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 3);
+lean_inc(x_9);
+lean_dec(x_1);
+x_10 = lean_apply_4(x_2, x_6, x_7, x_8, x_9);
+return x_10;
+}
+else
+{
+lean_object* x_11; 
+lean_dec(x_2);
+x_11 = lean_apply_1(x_3, x_1);
+return x_11;
+}
+}
+}
+}
+lean_object* l_Std_RBNode_appendTrees_match__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_appendTrees_match__2___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_appendTrees_match__3___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_9; 
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_6);
+lean_dec(x_5);
+lean_dec(x_4);
+x_9 = lean_apply_1(x_3, x_2);
+return x_9;
+}
+else
+{
+uint8_t x_10; 
+lean_dec(x_3);
+x_10 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+if (x_10 == 0)
+{
+lean_dec(x_7);
+lean_dec(x_6);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_11; 
+lean_dec(x_8);
+lean_dec(x_5);
+x_11 = lean_apply_1(x_4, x_1);
+return x_11;
+}
+else
+{
+uint8_t x_12; 
+lean_dec(x_4);
+x_12 = lean_ctor_get_uint8(x_2, sizeof(void*)*4);
+if (x_12 == 0)
+{
+lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
+lean_dec(x_8);
+x_13 = lean_ctor_get(x_1, 0);
+lean_inc(x_13);
+x_14 = lean_ctor_get(x_1, 1);
+lean_inc(x_14);
+x_15 = lean_ctor_get(x_1, 2);
+lean_inc(x_15);
+x_16 = lean_ctor_get(x_1, 3);
+lean_inc(x_16);
+lean_dec(x_1);
+x_17 = lean_ctor_get(x_2, 0);
+lean_inc(x_17);
+x_18 = lean_ctor_get(x_2, 1);
+lean_inc(x_18);
+x_19 = lean_ctor_get(x_2, 2);
+lean_inc(x_19);
+x_20 = lean_ctor_get(x_2, 3);
+lean_inc(x_20);
+lean_dec(x_2);
+x_21 = lean_apply_8(x_5, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20);
+return x_21;
+}
+else
+{
+lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; 
+lean_dec(x_5);
+x_22 = lean_ctor_get(x_1, 0);
+lean_inc(x_22);
+x_23 = lean_ctor_get(x_1, 1);
+lean_inc(x_23);
+x_24 = lean_ctor_get(x_1, 2);
+lean_inc(x_24);
+x_25 = lean_ctor_get(x_1, 3);
+lean_inc(x_25);
+lean_dec(x_1);
+x_26 = lean_apply_5(x_8, x_22, x_23, x_24, x_25, x_2);
+return x_26;
+}
+}
+}
+else
+{
+lean_dec(x_8);
+lean_dec(x_5);
+if (lean_obj_tag(x_2) == 0)
+{
+lean_object* x_27; 
+lean_dec(x_7);
+lean_dec(x_6);
+x_27 = lean_apply_1(x_4, x_1);
+return x_27;
+}
+else
+{
+uint8_t x_28; 
+lean_dec(x_4);
+x_28 = lean_ctor_get_uint8(x_2, sizeof(void*)*4);
+if (x_28 == 0)
+{
+lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; 
+lean_dec(x_6);
+x_29 = lean_ctor_get(x_2, 0);
+lean_inc(x_29);
+x_30 = lean_ctor_get(x_2, 1);
+lean_inc(x_30);
+x_31 = lean_ctor_get(x_2, 2);
+lean_inc(x_31);
+x_32 = lean_ctor_get(x_2, 3);
+lean_inc(x_32);
+lean_dec(x_2);
+x_33 = lean_apply_5(x_7, x_1, x_29, x_30, x_31, x_32);
+return x_33;
+}
+else
+{
+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_dec(x_7);
+x_34 = lean_ctor_get(x_1, 0);
+lean_inc(x_34);
+x_35 = lean_ctor_get(x_1, 1);
+lean_inc(x_35);
+x_36 = lean_ctor_get(x_1, 2);
+lean_inc(x_36);
+x_37 = lean_ctor_get(x_1, 3);
+lean_inc(x_37);
+lean_dec(x_1);
+x_38 = lean_ctor_get(x_2, 0);
+lean_inc(x_38);
+x_39 = lean_ctor_get(x_2, 1);
+lean_inc(x_39);
+x_40 = lean_ctor_get(x_2, 2);
+lean_inc(x_40);
+x_41 = lean_ctor_get(x_2, 3);
+lean_inc(x_41);
+lean_dec(x_2);
+x_42 = lean_apply_8(x_6, x_34, x_35, x_36, x_37, x_38, x_39, x_40, x_41);
+return x_42;
+}
+}
+}
+}
+}
+}
+lean_object* l_Std_RBNode_appendTrees_match__3(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_appendTrees_match__3___rarg), 8, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_appendTrees___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_1) == 0)
@@ -21528,346 +18568,363 @@ x_8 = lean_ctor_get(x_1, 1);
 x_9 = lean_ctor_get(x_1, 2);
 x_10 = lean_ctor_get(x_1, 3);
 x_11 = lean_ctor_get(x_2, 0);
-x_12 = l_Std_RBNode_appendTrees___main___rarg(x_10, x_11);
+x_12 = l_Std_RBNode_appendTrees___rarg(x_10, x_11);
 if (lean_obj_tag(x_12) == 0)
 {
+uint8_t x_13; 
+x_13 = 0;
 lean_ctor_set(x_2, 0, x_12);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_13);
 lean_ctor_set(x_1, 3, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_4);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_13);
 return x_1;
 }
 else
 {
-uint8_t x_13; 
-x_13 = lean_ctor_get_uint8(x_12, sizeof(void*)*4);
-if (x_13 == 0)
-{
 uint8_t x_14; 
-x_14 = !lean_is_exclusive(x_12);
+x_14 = lean_ctor_get_uint8(x_12, sizeof(void*)*4);
 if (x_14 == 0)
 {
-lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; 
-x_15 = lean_ctor_get(x_12, 0);
-x_16 = lean_ctor_get(x_12, 1);
-x_17 = lean_ctor_get(x_12, 2);
-x_18 = lean_ctor_get(x_12, 3);
-lean_ctor_set(x_12, 3, x_15);
+uint8_t x_15; 
+x_15 = !lean_is_exclusive(x_12);
+if (x_15 == 0)
+{
+lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; 
+x_16 = lean_ctor_get(x_12, 0);
+x_17 = lean_ctor_get(x_12, 1);
+x_18 = lean_ctor_get(x_12, 2);
+x_19 = lean_ctor_get(x_12, 3);
+x_20 = 0;
+lean_ctor_set(x_12, 3, x_16);
 lean_ctor_set(x_12, 2, x_9);
 lean_ctor_set(x_12, 1, x_8);
 lean_ctor_set(x_12, 0, x_7);
-lean_ctor_set(x_2, 0, x_18);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_13);
+lean_ctor_set_uint8(x_12, sizeof(void*)*4, x_20);
+lean_ctor_set(x_2, 0, x_19);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_20);
 lean_ctor_set(x_1, 3, x_2);
-lean_ctor_set(x_1, 2, x_17);
-lean_ctor_set(x_1, 1, x_16);
+lean_ctor_set(x_1, 2, x_18);
+lean_ctor_set(x_1, 1, x_17);
 lean_ctor_set(x_1, 0, x_12);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_13);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_20);
 return x_1;
 }
 else
 {
-lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; 
-x_19 = lean_ctor_get(x_12, 0);
-x_20 = lean_ctor_get(x_12, 1);
-x_21 = lean_ctor_get(x_12, 2);
-x_22 = lean_ctor_get(x_12, 3);
+lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; 
+x_21 = lean_ctor_get(x_12, 0);
+x_22 = lean_ctor_get(x_12, 1);
+x_23 = lean_ctor_get(x_12, 2);
+x_24 = lean_ctor_get(x_12, 3);
+lean_inc(x_24);
+lean_inc(x_23);
 lean_inc(x_22);
 lean_inc(x_21);
-lean_inc(x_20);
-lean_inc(x_19);
 lean_dec(x_12);
-x_23 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_23, 0, x_7);
-lean_ctor_set(x_23, 1, x_8);
-lean_ctor_set(x_23, 2, x_9);
-lean_ctor_set(x_23, 3, x_19);
-lean_ctor_set_uint8(x_23, sizeof(void*)*4, x_13);
-lean_ctor_set(x_2, 0, x_22);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_13);
+x_25 = 0;
+x_26 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_26, 0, x_7);
+lean_ctor_set(x_26, 1, x_8);
+lean_ctor_set(x_26, 2, x_9);
+lean_ctor_set(x_26, 3, x_21);
+lean_ctor_set_uint8(x_26, sizeof(void*)*4, x_25);
+lean_ctor_set(x_2, 0, x_24);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_25);
 lean_ctor_set(x_1, 3, x_2);
-lean_ctor_set(x_1, 2, x_21);
-lean_ctor_set(x_1, 1, x_20);
-lean_ctor_set(x_1, 0, x_23);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_13);
+lean_ctor_set(x_1, 2, x_23);
+lean_ctor_set(x_1, 1, x_22);
+lean_ctor_set(x_1, 0, x_26);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_25);
 return x_1;
 }
 }
 else
 {
+uint8_t x_27; 
+x_27 = 0;
 lean_ctor_set(x_2, 0, x_12);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_27);
 lean_ctor_set(x_1, 3, x_2);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_4);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_27);
 return x_1;
 }
 }
 }
 else
 {
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; 
-x_24 = lean_ctor_get(x_1, 0);
-x_25 = lean_ctor_get(x_1, 1);
-x_26 = lean_ctor_get(x_1, 2);
-x_27 = lean_ctor_get(x_1, 3);
-x_28 = lean_ctor_get(x_2, 0);
-x_29 = lean_ctor_get(x_2, 1);
-x_30 = lean_ctor_get(x_2, 2);
-x_31 = lean_ctor_get(x_2, 3);
-lean_inc(x_31);
-lean_inc(x_30);
-lean_inc(x_29);
-lean_inc(x_28);
-lean_dec(x_2);
-x_32 = l_Std_RBNode_appendTrees___main___rarg(x_27, x_28);
-if (lean_obj_tag(x_32) == 0)
-{
-lean_object* x_33; 
-x_33 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_33, 0, x_32);
-lean_ctor_set(x_33, 1, x_29);
-lean_ctor_set(x_33, 2, x_30);
-lean_ctor_set(x_33, 3, x_31);
-lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_4);
-lean_ctor_set(x_1, 3, x_33);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_4);
-return x_1;
-}
-else
-{
-uint8_t x_34; 
-x_34 = lean_ctor_get_uint8(x_32, sizeof(void*)*4);
-if (x_34 == 0)
-{
-lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; 
-x_35 = lean_ctor_get(x_32, 0);
+lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; 
+x_28 = lean_ctor_get(x_1, 0);
+x_29 = lean_ctor_get(x_1, 1);
+x_30 = lean_ctor_get(x_1, 2);
+x_31 = lean_ctor_get(x_1, 3);
+x_32 = lean_ctor_get(x_2, 0);
+x_33 = lean_ctor_get(x_2, 1);
+x_34 = lean_ctor_get(x_2, 2);
+x_35 = lean_ctor_get(x_2, 3);
 lean_inc(x_35);
-x_36 = lean_ctor_get(x_32, 1);
-lean_inc(x_36);
-x_37 = lean_ctor_get(x_32, 2);
-lean_inc(x_37);
-x_38 = lean_ctor_get(x_32, 3);
-lean_inc(x_38);
-if (lean_is_exclusive(x_32)) {
- lean_ctor_release(x_32, 0);
- lean_ctor_release(x_32, 1);
- lean_ctor_release(x_32, 2);
- lean_ctor_release(x_32, 3);
- x_39 = x_32;
-} else {
- lean_dec_ref(x_32);
- x_39 = lean_box(0);
-}
-if (lean_is_scalar(x_39)) {
- x_40 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_40 = x_39;
-}
-lean_ctor_set(x_40, 0, x_24);
-lean_ctor_set(x_40, 1, x_25);
-lean_ctor_set(x_40, 2, x_26);
-lean_ctor_set(x_40, 3, x_35);
-lean_ctor_set_uint8(x_40, sizeof(void*)*4, x_34);
-x_41 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_41, 0, x_38);
-lean_ctor_set(x_41, 1, x_29);
-lean_ctor_set(x_41, 2, x_30);
-lean_ctor_set(x_41, 3, x_31);
-lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_34);
-lean_ctor_set(x_1, 3, x_41);
-lean_ctor_set(x_1, 2, x_37);
-lean_ctor_set(x_1, 1, x_36);
-lean_ctor_set(x_1, 0, x_40);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_34);
+lean_inc(x_34);
+lean_inc(x_33);
+lean_inc(x_32);
+lean_dec(x_2);
+x_36 = l_Std_RBNode_appendTrees___rarg(x_31, x_32);
+if (lean_obj_tag(x_36) == 0)
+{
+uint8_t x_37; lean_object* x_38; 
+x_37 = 0;
+x_38 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_38, 0, x_36);
+lean_ctor_set(x_38, 1, x_33);
+lean_ctor_set(x_38, 2, x_34);
+lean_ctor_set(x_38, 3, x_35);
+lean_ctor_set_uint8(x_38, sizeof(void*)*4, x_37);
+lean_ctor_set(x_1, 3, x_38);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_37);
 return x_1;
 }
 else
 {
-lean_object* x_42; 
-x_42 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_42, 0, x_32);
-lean_ctor_set(x_42, 1, x_29);
-lean_ctor_set(x_42, 2, x_30);
-lean_ctor_set(x_42, 3, x_31);
-lean_ctor_set_uint8(x_42, sizeof(void*)*4, x_4);
-lean_ctor_set(x_1, 3, x_42);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_4);
-return x_1;
-}
-}
-}
-}
-else
+uint8_t x_39; 
+x_39 = lean_ctor_get_uint8(x_36, sizeof(void*)*4);
+if (x_39 == 0)
 {
-lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; 
-x_43 = lean_ctor_get(x_1, 0);
-x_44 = lean_ctor_get(x_1, 1);
-x_45 = lean_ctor_get(x_1, 2);
-x_46 = lean_ctor_get(x_1, 3);
-lean_inc(x_46);
-lean_inc(x_45);
-lean_inc(x_44);
+lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; lean_object* x_46; lean_object* x_47; 
+x_40 = lean_ctor_get(x_36, 0);
+lean_inc(x_40);
+x_41 = lean_ctor_get(x_36, 1);
+lean_inc(x_41);
+x_42 = lean_ctor_get(x_36, 2);
+lean_inc(x_42);
+x_43 = lean_ctor_get(x_36, 3);
 lean_inc(x_43);
-lean_dec(x_1);
-x_47 = lean_ctor_get(x_2, 0);
-lean_inc(x_47);
-x_48 = lean_ctor_get(x_2, 1);
-lean_inc(x_48);
-x_49 = lean_ctor_get(x_2, 2);
-lean_inc(x_49);
-x_50 = lean_ctor_get(x_2, 3);
+if (lean_is_exclusive(x_36)) {
+ lean_ctor_release(x_36, 0);
+ lean_ctor_release(x_36, 1);
+ lean_ctor_release(x_36, 2);
+ lean_ctor_release(x_36, 3);
+ x_44 = x_36;
+} else {
+ lean_dec_ref(x_36);
+ x_44 = lean_box(0);
+}
+x_45 = 0;
+if (lean_is_scalar(x_44)) {
+ x_46 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_46 = x_44;
+}
+lean_ctor_set(x_46, 0, x_28);
+lean_ctor_set(x_46, 1, x_29);
+lean_ctor_set(x_46, 2, x_30);
+lean_ctor_set(x_46, 3, x_40);
+lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_45);
+x_47 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_47, 0, x_43);
+lean_ctor_set(x_47, 1, x_33);
+lean_ctor_set(x_47, 2, x_34);
+lean_ctor_set(x_47, 3, x_35);
+lean_ctor_set_uint8(x_47, sizeof(void*)*4, x_45);
+lean_ctor_set(x_1, 3, x_47);
+lean_ctor_set(x_1, 2, x_42);
+lean_ctor_set(x_1, 1, x_41);
+lean_ctor_set(x_1, 0, x_46);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_45);
+return x_1;
+}
+else
+{
+uint8_t x_48; lean_object* x_49; 
+x_48 = 0;
+x_49 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_49, 0, x_36);
+lean_ctor_set(x_49, 1, x_33);
+lean_ctor_set(x_49, 2, x_34);
+lean_ctor_set(x_49, 3, x_35);
+lean_ctor_set_uint8(x_49, sizeof(void*)*4, x_48);
+lean_ctor_set(x_1, 3, x_49);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_48);
+return x_1;
+}
+}
+}
+}
+else
+{
+lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; 
+x_50 = lean_ctor_get(x_1, 0);
+x_51 = lean_ctor_get(x_1, 1);
+x_52 = lean_ctor_get(x_1, 2);
+x_53 = lean_ctor_get(x_1, 3);
+lean_inc(x_53);
+lean_inc(x_52);
+lean_inc(x_51);
 lean_inc(x_50);
+lean_dec(x_1);
+x_54 = lean_ctor_get(x_2, 0);
+lean_inc(x_54);
+x_55 = lean_ctor_get(x_2, 1);
+lean_inc(x_55);
+x_56 = lean_ctor_get(x_2, 2);
+lean_inc(x_56);
+x_57 = lean_ctor_get(x_2, 3);
+lean_inc(x_57);
 if (lean_is_exclusive(x_2)) {
  lean_ctor_release(x_2, 0);
  lean_ctor_release(x_2, 1);
  lean_ctor_release(x_2, 2);
  lean_ctor_release(x_2, 3);
- x_51 = x_2;
+ x_58 = x_2;
 } else {
  lean_dec_ref(x_2);
- x_51 = lean_box(0);
+ x_58 = lean_box(0);
 }
-x_52 = l_Std_RBNode_appendTrees___main___rarg(x_46, x_47);
-if (lean_obj_tag(x_52) == 0)
+x_59 = l_Std_RBNode_appendTrees___rarg(x_53, x_54);
+if (lean_obj_tag(x_59) == 0)
 {
-lean_object* x_53; lean_object* x_54; 
-if (lean_is_scalar(x_51)) {
- x_53 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_53 = x_51;
-}
-lean_ctor_set(x_53, 0, x_52);
-lean_ctor_set(x_53, 1, x_48);
-lean_ctor_set(x_53, 2, x_49);
-lean_ctor_set(x_53, 3, x_50);
-lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_4);
-x_54 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_54, 0, x_43);
-lean_ctor_set(x_54, 1, x_44);
-lean_ctor_set(x_54, 2, x_45);
-lean_ctor_set(x_54, 3, x_53);
-lean_ctor_set_uint8(x_54, sizeof(void*)*4, x_4);
-return x_54;
-}
-else
-{
-uint8_t x_55; 
-x_55 = lean_ctor_get_uint8(x_52, sizeof(void*)*4);
-if (x_55 == 0)
-{
-lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; 
-x_56 = lean_ctor_get(x_52, 0);
-lean_inc(x_56);
-x_57 = lean_ctor_get(x_52, 1);
-lean_inc(x_57);
-x_58 = lean_ctor_get(x_52, 2);
-lean_inc(x_58);
-x_59 = lean_ctor_get(x_52, 3);
-lean_inc(x_59);
-if (lean_is_exclusive(x_52)) {
- lean_ctor_release(x_52, 0);
- lean_ctor_release(x_52, 1);
- lean_ctor_release(x_52, 2);
- lean_ctor_release(x_52, 3);
- x_60 = x_52;
-} else {
- lean_dec_ref(x_52);
- x_60 = lean_box(0);
-}
-if (lean_is_scalar(x_60)) {
+uint8_t x_60; lean_object* x_61; lean_object* x_62; 
+x_60 = 0;
+if (lean_is_scalar(x_58)) {
  x_61 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_61 = x_60;
+ x_61 = x_58;
 }
-lean_ctor_set(x_61, 0, x_43);
-lean_ctor_set(x_61, 1, x_44);
-lean_ctor_set(x_61, 2, x_45);
-lean_ctor_set(x_61, 3, x_56);
-lean_ctor_set_uint8(x_61, sizeof(void*)*4, x_55);
-if (lean_is_scalar(x_51)) {
- x_62 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_62 = x_51;
-}
-lean_ctor_set(x_62, 0, x_59);
-lean_ctor_set(x_62, 1, x_48);
-lean_ctor_set(x_62, 2, x_49);
-lean_ctor_set(x_62, 3, x_50);
-lean_ctor_set_uint8(x_62, sizeof(void*)*4, x_55);
-x_63 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_63, 0, x_61);
-lean_ctor_set(x_63, 1, x_57);
-lean_ctor_set(x_63, 2, x_58);
-lean_ctor_set(x_63, 3, x_62);
-lean_ctor_set_uint8(x_63, sizeof(void*)*4, x_55);
-return x_63;
+lean_ctor_set(x_61, 0, x_59);
+lean_ctor_set(x_61, 1, x_55);
+lean_ctor_set(x_61, 2, x_56);
+lean_ctor_set(x_61, 3, x_57);
+lean_ctor_set_uint8(x_61, sizeof(void*)*4, x_60);
+x_62 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_62, 0, x_50);
+lean_ctor_set(x_62, 1, x_51);
+lean_ctor_set(x_62, 2, x_52);
+lean_ctor_set(x_62, 3, x_61);
+lean_ctor_set_uint8(x_62, sizeof(void*)*4, x_60);
+return x_62;
 }
 else
 {
-lean_object* x_64; lean_object* x_65; 
-if (lean_is_scalar(x_51)) {
- x_64 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_64 = x_51;
-}
-lean_ctor_set(x_64, 0, x_52);
-lean_ctor_set(x_64, 1, x_48);
-lean_ctor_set(x_64, 2, x_49);
-lean_ctor_set(x_64, 3, x_50);
-lean_ctor_set_uint8(x_64, sizeof(void*)*4, x_4);
-x_65 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_65, 0, x_43);
-lean_ctor_set(x_65, 1, x_44);
-lean_ctor_set(x_65, 2, x_45);
-lean_ctor_set(x_65, 3, x_64);
-lean_ctor_set_uint8(x_65, sizeof(void*)*4, x_4);
-return x_65;
-}
-}
-}
-}
-else
+uint8_t x_63; 
+x_63 = lean_ctor_get_uint8(x_59, sizeof(void*)*4);
+if (x_63 == 0)
 {
-lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; 
-x_66 = lean_ctor_get(x_1, 0);
+lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; 
+x_64 = lean_ctor_get(x_59, 0);
+lean_inc(x_64);
+x_65 = lean_ctor_get(x_59, 1);
+lean_inc(x_65);
+x_66 = lean_ctor_get(x_59, 2);
 lean_inc(x_66);
-x_67 = lean_ctor_get(x_1, 1);
+x_67 = lean_ctor_get(x_59, 3);
 lean_inc(x_67);
-x_68 = lean_ctor_get(x_1, 2);
-lean_inc(x_68);
-x_69 = lean_ctor_get(x_1, 3);
-lean_inc(x_69);
+if (lean_is_exclusive(x_59)) {
+ lean_ctor_release(x_59, 0);
+ lean_ctor_release(x_59, 1);
+ lean_ctor_release(x_59, 2);
+ lean_ctor_release(x_59, 3);
+ x_68 = x_59;
+} else {
+ lean_dec_ref(x_59);
+ x_68 = lean_box(0);
+}
+x_69 = 0;
+if (lean_is_scalar(x_68)) {
+ x_70 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_70 = x_68;
+}
+lean_ctor_set(x_70, 0, x_50);
+lean_ctor_set(x_70, 1, x_51);
+lean_ctor_set(x_70, 2, x_52);
+lean_ctor_set(x_70, 3, x_64);
+lean_ctor_set_uint8(x_70, sizeof(void*)*4, x_69);
+if (lean_is_scalar(x_58)) {
+ x_71 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_71 = x_58;
+}
+lean_ctor_set(x_71, 0, x_67);
+lean_ctor_set(x_71, 1, x_55);
+lean_ctor_set(x_71, 2, x_56);
+lean_ctor_set(x_71, 3, x_57);
+lean_ctor_set_uint8(x_71, sizeof(void*)*4, x_69);
+x_72 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_72, 0, x_70);
+lean_ctor_set(x_72, 1, x_65);
+lean_ctor_set(x_72, 2, x_66);
+lean_ctor_set(x_72, 3, x_71);
+lean_ctor_set_uint8(x_72, sizeof(void*)*4, x_69);
+return x_72;
+}
+else
+{
+uint8_t x_73; lean_object* x_74; lean_object* x_75; 
+x_73 = 0;
+if (lean_is_scalar(x_58)) {
+ x_74 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_74 = x_58;
+}
+lean_ctor_set(x_74, 0, x_59);
+lean_ctor_set(x_74, 1, x_55);
+lean_ctor_set(x_74, 2, x_56);
+lean_ctor_set(x_74, 3, x_57);
+lean_ctor_set_uint8(x_74, sizeof(void*)*4, x_73);
+x_75 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_75, 0, x_50);
+lean_ctor_set(x_75, 1, x_51);
+lean_ctor_set(x_75, 2, x_52);
+lean_ctor_set(x_75, 3, x_74);
+lean_ctor_set_uint8(x_75, sizeof(void*)*4, x_73);
+return x_75;
+}
+}
+}
+}
+else
+{
+lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; 
+x_76 = lean_ctor_get(x_1, 0);
+lean_inc(x_76);
+x_77 = lean_ctor_get(x_1, 1);
+lean_inc(x_77);
+x_78 = lean_ctor_get(x_1, 2);
+lean_inc(x_78);
+x_79 = lean_ctor_get(x_1, 3);
+lean_inc(x_79);
 lean_dec(x_1);
 lean_inc(x_2);
-x_70 = l_Std_RBNode_appendTrees___main___rarg(x_69, x_2);
-x_71 = !lean_is_exclusive(x_2);
-if (x_71 == 0)
+x_80 = l_Std_RBNode_appendTrees___rarg(x_79, x_2);
+x_81 = !lean_is_exclusive(x_2);
+if (x_81 == 0)
 {
-lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; 
-x_72 = lean_ctor_get(x_2, 3);
-lean_dec(x_72);
-x_73 = lean_ctor_get(x_2, 2);
-lean_dec(x_73);
-x_74 = lean_ctor_get(x_2, 1);
-lean_dec(x_74);
-x_75 = lean_ctor_get(x_2, 0);
-lean_dec(x_75);
-lean_ctor_set(x_2, 3, x_70);
-lean_ctor_set(x_2, 2, x_68);
-lean_ctor_set(x_2, 1, x_67);
-lean_ctor_set(x_2, 0, x_66);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_3);
+lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; 
+x_82 = lean_ctor_get(x_2, 3);
+lean_dec(x_82);
+x_83 = lean_ctor_get(x_2, 2);
+lean_dec(x_83);
+x_84 = lean_ctor_get(x_2, 1);
+lean_dec(x_84);
+x_85 = lean_ctor_get(x_2, 0);
+lean_dec(x_85);
+x_86 = 0;
+lean_ctor_set(x_2, 3, x_80);
+lean_ctor_set(x_2, 2, x_78);
+lean_ctor_set(x_2, 1, x_77);
+lean_ctor_set(x_2, 0, x_76);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_86);
 return x_2;
 }
 else
 {
-lean_object* x_76; 
+uint8_t x_87; lean_object* x_88; 
 lean_dec(x_2);
-x_76 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_76, 0, x_66);
-lean_ctor_set(x_76, 1, x_67);
-lean_ctor_set(x_76, 2, x_68);
-lean_ctor_set(x_76, 3, x_70);
-lean_ctor_set_uint8(x_76, sizeof(void*)*4, x_3);
-return x_76;
+x_87 = 0;
+x_88 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_88, 0, x_76);
+lean_ctor_set(x_88, 1, x_77);
+lean_ctor_set(x_88, 2, x_78);
+lean_ctor_set(x_88, 3, x_80);
+lean_ctor_set_uint8(x_88, sizeof(void*)*4, x_87);
+return x_88;
 }
 }
 }
@@ -21880,342 +18937,362 @@ return x_1;
 }
 else
 {
-uint8_t x_77; 
-x_77 = lean_ctor_get_uint8(x_2, sizeof(void*)*4);
-if (x_77 == 0)
+uint8_t x_89; 
+x_89 = lean_ctor_get_uint8(x_2, sizeof(void*)*4);
+if (x_89 == 0)
 {
-uint8_t x_78; 
-x_78 = !lean_is_exclusive(x_2);
-if (x_78 == 0)
+uint8_t x_90; 
+x_90 = !lean_is_exclusive(x_2);
+if (x_90 == 0)
 {
-lean_object* x_79; lean_object* x_80; 
-x_79 = lean_ctor_get(x_2, 0);
-x_80 = l_Std_RBNode_appendTrees___main___rarg(x_1, x_79);
-lean_ctor_set(x_2, 0, x_80);
+lean_object* x_91; lean_object* x_92; uint8_t x_93; 
+x_91 = lean_ctor_get(x_2, 0);
+x_92 = l_Std_RBNode_appendTrees___rarg(x_1, x_91);
+x_93 = 0;
+lean_ctor_set(x_2, 0, x_92);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_93);
 return x_2;
 }
 else
 {
-lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; 
-x_81 = lean_ctor_get(x_2, 0);
-x_82 = lean_ctor_get(x_2, 1);
-x_83 = lean_ctor_get(x_2, 2);
-x_84 = lean_ctor_get(x_2, 3);
-lean_inc(x_84);
-lean_inc(x_83);
-lean_inc(x_82);
-lean_inc(x_81);
+lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; 
+x_94 = lean_ctor_get(x_2, 0);
+x_95 = lean_ctor_get(x_2, 1);
+x_96 = lean_ctor_get(x_2, 2);
+x_97 = lean_ctor_get(x_2, 3);
+lean_inc(x_97);
+lean_inc(x_96);
+lean_inc(x_95);
+lean_inc(x_94);
 lean_dec(x_2);
-x_85 = l_Std_RBNode_appendTrees___main___rarg(x_1, x_81);
-x_86 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_86, 0, x_85);
-lean_ctor_set(x_86, 1, x_82);
-lean_ctor_set(x_86, 2, x_83);
-lean_ctor_set(x_86, 3, x_84);
-lean_ctor_set_uint8(x_86, sizeof(void*)*4, x_77);
-return x_86;
+x_98 = l_Std_RBNode_appendTrees___rarg(x_1, x_94);
+x_99 = 0;
+x_100 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_100, 0, x_98);
+lean_ctor_set(x_100, 1, x_95);
+lean_ctor_set(x_100, 2, x_96);
+lean_ctor_set(x_100, 3, x_97);
+lean_ctor_set_uint8(x_100, sizeof(void*)*4, x_99);
+return x_100;
 }
 }
 else
 {
-uint8_t x_87; 
-x_87 = !lean_is_exclusive(x_1);
-if (x_87 == 0)
+uint8_t x_101; 
+x_101 = !lean_is_exclusive(x_1);
+if (x_101 == 0)
 {
-uint8_t x_88; 
-x_88 = !lean_is_exclusive(x_2);
-if (x_88 == 0)
+uint8_t x_102; 
+x_102 = !lean_is_exclusive(x_2);
+if (x_102 == 0)
 {
-lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; 
-x_89 = lean_ctor_get(x_1, 0);
-x_90 = lean_ctor_get(x_1, 1);
-x_91 = lean_ctor_get(x_1, 2);
-x_92 = lean_ctor_get(x_1, 3);
-x_93 = lean_ctor_get(x_2, 0);
-x_94 = l_Std_RBNode_appendTrees___main___rarg(x_92, x_93);
-if (lean_obj_tag(x_94) == 0)
+lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; 
+x_103 = lean_ctor_get(x_1, 0);
+x_104 = lean_ctor_get(x_1, 1);
+x_105 = lean_ctor_get(x_1, 2);
+x_106 = lean_ctor_get(x_1, 3);
+x_107 = lean_ctor_get(x_2, 0);
+x_108 = l_Std_RBNode_appendTrees___rarg(x_106, x_107);
+if (lean_obj_tag(x_108) == 0)
 {
-lean_object* x_95; 
+uint8_t x_109; lean_object* x_110; 
 lean_free_object(x_1);
-lean_ctor_set(x_2, 0, x_94);
-x_95 = l_Std_RBNode_balLeft___rarg(x_89, x_90, x_91, x_2);
-return x_95;
+x_109 = 1;
+lean_ctor_set(x_2, 0, x_108);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_109);
+x_110 = l_Std_RBNode_balLeft___rarg(x_103, x_104, x_105, x_2);
+return x_110;
 }
 else
 {
-uint8_t x_96; 
-x_96 = lean_ctor_get_uint8(x_94, sizeof(void*)*4);
-if (x_96 == 0)
+uint8_t x_111; 
+x_111 = lean_ctor_get_uint8(x_108, sizeof(void*)*4);
+if (x_111 == 0)
 {
-uint8_t x_97; 
-x_97 = !lean_is_exclusive(x_94);
-if (x_97 == 0)
+uint8_t x_112; 
+x_112 = !lean_is_exclusive(x_108);
+if (x_112 == 0)
 {
-lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; 
-x_98 = lean_ctor_get(x_94, 0);
-x_99 = lean_ctor_get(x_94, 1);
-x_100 = lean_ctor_get(x_94, 2);
-x_101 = lean_ctor_get(x_94, 3);
-lean_ctor_set(x_94, 3, x_98);
-lean_ctor_set(x_94, 2, x_91);
-lean_ctor_set(x_94, 1, x_90);
-lean_ctor_set(x_94, 0, x_89);
-lean_ctor_set_uint8(x_94, sizeof(void*)*4, x_77);
-lean_ctor_set(x_2, 0, x_101);
+lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint8_t x_117; uint8_t x_118; 
+x_113 = lean_ctor_get(x_108, 0);
+x_114 = lean_ctor_get(x_108, 1);
+x_115 = lean_ctor_get(x_108, 2);
+x_116 = lean_ctor_get(x_108, 3);
+x_117 = 1;
+lean_ctor_set(x_108, 3, x_113);
+lean_ctor_set(x_108, 2, x_105);
+lean_ctor_set(x_108, 1, x_104);
+lean_ctor_set(x_108, 0, x_103);
+lean_ctor_set_uint8(x_108, sizeof(void*)*4, x_117);
+lean_ctor_set(x_2, 0, x_116);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_117);
+x_118 = 0;
 lean_ctor_set(x_1, 3, x_2);
-lean_ctor_set(x_1, 2, x_100);
-lean_ctor_set(x_1, 1, x_99);
-lean_ctor_set(x_1, 0, x_94);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_96);
+lean_ctor_set(x_1, 2, x_115);
+lean_ctor_set(x_1, 1, x_114);
+lean_ctor_set(x_1, 0, x_108);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_118);
 return x_1;
 }
 else
 {
-lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; 
-x_102 = lean_ctor_get(x_94, 0);
-x_103 = lean_ctor_get(x_94, 1);
-x_104 = lean_ctor_get(x_94, 2);
-x_105 = lean_ctor_get(x_94, 3);
-lean_inc(x_105);
-lean_inc(x_104);
-lean_inc(x_103);
-lean_inc(x_102);
-lean_dec(x_94);
-x_106 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_106, 0, x_89);
-lean_ctor_set(x_106, 1, x_90);
-lean_ctor_set(x_106, 2, x_91);
-lean_ctor_set(x_106, 3, x_102);
-lean_ctor_set_uint8(x_106, sizeof(void*)*4, x_77);
-lean_ctor_set(x_2, 0, x_105);
-lean_ctor_set(x_1, 3, x_2);
-lean_ctor_set(x_1, 2, x_104);
-lean_ctor_set(x_1, 1, x_103);
-lean_ctor_set(x_1, 0, x_106);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_96);
-return x_1;
-}
-}
-else
-{
-lean_object* x_107; 
-lean_free_object(x_1);
-lean_ctor_set(x_2, 0, x_94);
-lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_96);
-x_107 = l_Std_RBNode_balLeft___rarg(x_89, x_90, x_91, x_2);
-return x_107;
-}
-}
-}
-else
-{
-lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; 
-x_108 = lean_ctor_get(x_1, 0);
-x_109 = lean_ctor_get(x_1, 1);
-x_110 = lean_ctor_get(x_1, 2);
-x_111 = lean_ctor_get(x_1, 3);
-x_112 = lean_ctor_get(x_2, 0);
-x_113 = lean_ctor_get(x_2, 1);
-x_114 = lean_ctor_get(x_2, 2);
-x_115 = lean_ctor_get(x_2, 3);
-lean_inc(x_115);
-lean_inc(x_114);
-lean_inc(x_113);
-lean_inc(x_112);
-lean_dec(x_2);
-x_116 = l_Std_RBNode_appendTrees___main___rarg(x_111, x_112);
-if (lean_obj_tag(x_116) == 0)
-{
-lean_object* x_117; lean_object* x_118; 
-lean_free_object(x_1);
-x_117 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_117, 0, x_116);
-lean_ctor_set(x_117, 1, x_113);
-lean_ctor_set(x_117, 2, x_114);
-lean_ctor_set(x_117, 3, x_115);
-lean_ctor_set_uint8(x_117, sizeof(void*)*4, x_77);
-x_118 = l_Std_RBNode_balLeft___rarg(x_108, x_109, x_110, x_117);
-return x_118;
-}
-else
-{
-uint8_t x_119; 
-x_119 = lean_ctor_get_uint8(x_116, sizeof(void*)*4);
-if (x_119 == 0)
-{
-lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; 
-x_120 = lean_ctor_get(x_116, 0);
-lean_inc(x_120);
-x_121 = lean_ctor_get(x_116, 1);
-lean_inc(x_121);
-x_122 = lean_ctor_get(x_116, 2);
+lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; uint8_t x_123; lean_object* x_124; uint8_t x_125; 
+x_119 = lean_ctor_get(x_108, 0);
+x_120 = lean_ctor_get(x_108, 1);
+x_121 = lean_ctor_get(x_108, 2);
+x_122 = lean_ctor_get(x_108, 3);
 lean_inc(x_122);
-x_123 = lean_ctor_get(x_116, 3);
-lean_inc(x_123);
-if (lean_is_exclusive(x_116)) {
- lean_ctor_release(x_116, 0);
- lean_ctor_release(x_116, 1);
- lean_ctor_release(x_116, 2);
- lean_ctor_release(x_116, 3);
- x_124 = x_116;
-} else {
- lean_dec_ref(x_116);
- x_124 = lean_box(0);
+lean_inc(x_121);
+lean_inc(x_120);
+lean_inc(x_119);
+lean_dec(x_108);
+x_123 = 1;
+x_124 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_124, 0, x_103);
+lean_ctor_set(x_124, 1, x_104);
+lean_ctor_set(x_124, 2, x_105);
+lean_ctor_set(x_124, 3, x_119);
+lean_ctor_set_uint8(x_124, sizeof(void*)*4, x_123);
+lean_ctor_set(x_2, 0, x_122);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_123);
+x_125 = 0;
+lean_ctor_set(x_1, 3, x_2);
+lean_ctor_set(x_1, 2, x_121);
+lean_ctor_set(x_1, 1, x_120);
+lean_ctor_set(x_1, 0, x_124);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_125);
+return x_1;
 }
-if (lean_is_scalar(x_124)) {
- x_125 = lean_alloc_ctor(1, 4, 1);
-} else {
- x_125 = x_124;
 }
-lean_ctor_set(x_125, 0, x_108);
-lean_ctor_set(x_125, 1, x_109);
-lean_ctor_set(x_125, 2, x_110);
-lean_ctor_set(x_125, 3, x_120);
-lean_ctor_set_uint8(x_125, sizeof(void*)*4, x_77);
-x_126 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_126, 0, x_123);
-lean_ctor_set(x_126, 1, x_113);
-lean_ctor_set(x_126, 2, x_114);
-lean_ctor_set(x_126, 3, x_115);
-lean_ctor_set_uint8(x_126, sizeof(void*)*4, x_77);
-lean_ctor_set(x_1, 3, x_126);
-lean_ctor_set(x_1, 2, x_122);
-lean_ctor_set(x_1, 1, x_121);
-lean_ctor_set(x_1, 0, x_125);
-lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_119);
+else
+{
+uint8_t x_126; lean_object* x_127; 
+lean_free_object(x_1);
+x_126 = 1;
+lean_ctor_set(x_2, 0, x_108);
+lean_ctor_set_uint8(x_2, sizeof(void*)*4, x_126);
+x_127 = l_Std_RBNode_balLeft___rarg(x_103, x_104, x_105, x_2);
+return x_127;
+}
+}
+}
+else
+{
+lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; 
+x_128 = lean_ctor_get(x_1, 0);
+x_129 = lean_ctor_get(x_1, 1);
+x_130 = lean_ctor_get(x_1, 2);
+x_131 = lean_ctor_get(x_1, 3);
+x_132 = lean_ctor_get(x_2, 0);
+x_133 = lean_ctor_get(x_2, 1);
+x_134 = lean_ctor_get(x_2, 2);
+x_135 = lean_ctor_get(x_2, 3);
+lean_inc(x_135);
+lean_inc(x_134);
+lean_inc(x_133);
+lean_inc(x_132);
+lean_dec(x_2);
+x_136 = l_Std_RBNode_appendTrees___rarg(x_131, x_132);
+if (lean_obj_tag(x_136) == 0)
+{
+uint8_t x_137; lean_object* x_138; lean_object* x_139; 
+lean_free_object(x_1);
+x_137 = 1;
+x_138 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_138, 0, x_136);
+lean_ctor_set(x_138, 1, x_133);
+lean_ctor_set(x_138, 2, x_134);
+lean_ctor_set(x_138, 3, x_135);
+lean_ctor_set_uint8(x_138, sizeof(void*)*4, x_137);
+x_139 = l_Std_RBNode_balLeft___rarg(x_128, x_129, x_130, x_138);
+return x_139;
+}
+else
+{
+uint8_t x_140; 
+x_140 = lean_ctor_get_uint8(x_136, sizeof(void*)*4);
+if (x_140 == 0)
+{
+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_object* x_147; lean_object* x_148; uint8_t x_149; 
+x_141 = lean_ctor_get(x_136, 0);
+lean_inc(x_141);
+x_142 = lean_ctor_get(x_136, 1);
+lean_inc(x_142);
+x_143 = lean_ctor_get(x_136, 2);
+lean_inc(x_143);
+x_144 = lean_ctor_get(x_136, 3);
+lean_inc(x_144);
+if (lean_is_exclusive(x_136)) {
+ lean_ctor_release(x_136, 0);
+ lean_ctor_release(x_136, 1);
+ lean_ctor_release(x_136, 2);
+ lean_ctor_release(x_136, 3);
+ x_145 = x_136;
+} else {
+ lean_dec_ref(x_136);
+ x_145 = lean_box(0);
+}
+x_146 = 1;
+if (lean_is_scalar(x_145)) {
+ x_147 = lean_alloc_ctor(1, 4, 1);
+} else {
+ x_147 = x_145;
+}
+lean_ctor_set(x_147, 0, x_128);
+lean_ctor_set(x_147, 1, x_129);
+lean_ctor_set(x_147, 2, x_130);
+lean_ctor_set(x_147, 3, x_141);
+lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_146);
+x_148 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_148, 0, x_144);
+lean_ctor_set(x_148, 1, x_133);
+lean_ctor_set(x_148, 2, x_134);
+lean_ctor_set(x_148, 3, x_135);
+lean_ctor_set_uint8(x_148, sizeof(void*)*4, x_146);
+x_149 = 0;
+lean_ctor_set(x_1, 3, x_148);
+lean_ctor_set(x_1, 2, x_143);
+lean_ctor_set(x_1, 1, x_142);
+lean_ctor_set(x_1, 0, x_147);
+lean_ctor_set_uint8(x_1, sizeof(void*)*4, x_149);
 return x_1;
 }
 else
 {
-lean_object* x_127; lean_object* x_128; 
+uint8_t x_150; lean_object* x_151; lean_object* x_152; 
 lean_free_object(x_1);
-x_127 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_127, 0, x_116);
-lean_ctor_set(x_127, 1, x_113);
-lean_ctor_set(x_127, 2, x_114);
-lean_ctor_set(x_127, 3, x_115);
-lean_ctor_set_uint8(x_127, sizeof(void*)*4, x_119);
-x_128 = l_Std_RBNode_balLeft___rarg(x_108, x_109, x_110, x_127);
-return x_128;
+x_150 = 1;
+x_151 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_151, 0, x_136);
+lean_ctor_set(x_151, 1, x_133);
+lean_ctor_set(x_151, 2, x_134);
+lean_ctor_set(x_151, 3, x_135);
+lean_ctor_set_uint8(x_151, sizeof(void*)*4, x_150);
+x_152 = l_Std_RBNode_balLeft___rarg(x_128, x_129, x_130, x_151);
+return x_152;
 }
 }
 }
 }
 else
 {
-lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; 
-x_129 = lean_ctor_get(x_1, 0);
-x_130 = lean_ctor_get(x_1, 1);
-x_131 = lean_ctor_get(x_1, 2);
-x_132 = lean_ctor_get(x_1, 3);
-lean_inc(x_132);
-lean_inc(x_131);
-lean_inc(x_130);
-lean_inc(x_129);
+lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; 
+x_153 = lean_ctor_get(x_1, 0);
+x_154 = lean_ctor_get(x_1, 1);
+x_155 = lean_ctor_get(x_1, 2);
+x_156 = lean_ctor_get(x_1, 3);
+lean_inc(x_156);
+lean_inc(x_155);
+lean_inc(x_154);
+lean_inc(x_153);
 lean_dec(x_1);
-x_133 = lean_ctor_get(x_2, 0);
-lean_inc(x_133);
-x_134 = lean_ctor_get(x_2, 1);
-lean_inc(x_134);
-x_135 = lean_ctor_get(x_2, 2);
-lean_inc(x_135);
-x_136 = lean_ctor_get(x_2, 3);
-lean_inc(x_136);
+x_157 = lean_ctor_get(x_2, 0);
+lean_inc(x_157);
+x_158 = lean_ctor_get(x_2, 1);
+lean_inc(x_158);
+x_159 = lean_ctor_get(x_2, 2);
+lean_inc(x_159);
+x_160 = lean_ctor_get(x_2, 3);
+lean_inc(x_160);
 if (lean_is_exclusive(x_2)) {
  lean_ctor_release(x_2, 0);
  lean_ctor_release(x_2, 1);
  lean_ctor_release(x_2, 2);
  lean_ctor_release(x_2, 3);
- x_137 = x_2;
+ x_161 = x_2;
 } else {
  lean_dec_ref(x_2);
- x_137 = lean_box(0);
+ x_161 = lean_box(0);
 }
-x_138 = l_Std_RBNode_appendTrees___main___rarg(x_132, x_133);
-if (lean_obj_tag(x_138) == 0)
+x_162 = l_Std_RBNode_appendTrees___rarg(x_156, x_157);
+if (lean_obj_tag(x_162) == 0)
 {
-lean_object* x_139; lean_object* x_140; 
-if (lean_is_scalar(x_137)) {
- x_139 = lean_alloc_ctor(1, 4, 1);
+uint8_t x_163; lean_object* x_164; lean_object* x_165; 
+x_163 = 1;
+if (lean_is_scalar(x_161)) {
+ x_164 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_139 = x_137;
+ x_164 = x_161;
 }
-lean_ctor_set(x_139, 0, x_138);
-lean_ctor_set(x_139, 1, x_134);
-lean_ctor_set(x_139, 2, x_135);
-lean_ctor_set(x_139, 3, x_136);
-lean_ctor_set_uint8(x_139, sizeof(void*)*4, x_77);
-x_140 = l_Std_RBNode_balLeft___rarg(x_129, x_130, x_131, x_139);
-return x_140;
+lean_ctor_set(x_164, 0, x_162);
+lean_ctor_set(x_164, 1, x_158);
+lean_ctor_set(x_164, 2, x_159);
+lean_ctor_set(x_164, 3, x_160);
+lean_ctor_set_uint8(x_164, sizeof(void*)*4, x_163);
+x_165 = l_Std_RBNode_balLeft___rarg(x_153, x_154, x_155, x_164);
+return x_165;
 }
 else
 {
-uint8_t x_141; 
-x_141 = lean_ctor_get_uint8(x_138, sizeof(void*)*4);
-if (x_141 == 0)
+uint8_t x_166; 
+x_166 = lean_ctor_get_uint8(x_162, sizeof(void*)*4);
+if (x_166 == 0)
 {
-lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; 
-x_142 = lean_ctor_get(x_138, 0);
-lean_inc(x_142);
-x_143 = lean_ctor_get(x_138, 1);
-lean_inc(x_143);
-x_144 = lean_ctor_get(x_138, 2);
-lean_inc(x_144);
-x_145 = lean_ctor_get(x_138, 3);
-lean_inc(x_145);
-if (lean_is_exclusive(x_138)) {
- lean_ctor_release(x_138, 0);
- lean_ctor_release(x_138, 1);
- lean_ctor_release(x_138, 2);
- lean_ctor_release(x_138, 3);
- x_146 = x_138;
+lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; uint8_t x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; lean_object* x_176; 
+x_167 = lean_ctor_get(x_162, 0);
+lean_inc(x_167);
+x_168 = lean_ctor_get(x_162, 1);
+lean_inc(x_168);
+x_169 = lean_ctor_get(x_162, 2);
+lean_inc(x_169);
+x_170 = lean_ctor_get(x_162, 3);
+lean_inc(x_170);
+if (lean_is_exclusive(x_162)) {
+ lean_ctor_release(x_162, 0);
+ lean_ctor_release(x_162, 1);
+ lean_ctor_release(x_162, 2);
+ lean_ctor_release(x_162, 3);
+ x_171 = x_162;
 } else {
- lean_dec_ref(x_138);
- x_146 = lean_box(0);
+ lean_dec_ref(x_162);
+ x_171 = lean_box(0);
 }
-if (lean_is_scalar(x_146)) {
- x_147 = lean_alloc_ctor(1, 4, 1);
+x_172 = 1;
+if (lean_is_scalar(x_171)) {
+ x_173 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_147 = x_146;
+ x_173 = x_171;
 }
-lean_ctor_set(x_147, 0, x_129);
-lean_ctor_set(x_147, 1, x_130);
-lean_ctor_set(x_147, 2, x_131);
-lean_ctor_set(x_147, 3, x_142);
-lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_77);
-if (lean_is_scalar(x_137)) {
- x_148 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_173, 0, x_153);
+lean_ctor_set(x_173, 1, x_154);
+lean_ctor_set(x_173, 2, x_155);
+lean_ctor_set(x_173, 3, x_167);
+lean_ctor_set_uint8(x_173, sizeof(void*)*4, x_172);
+if (lean_is_scalar(x_161)) {
+ x_174 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_148 = x_137;
+ x_174 = x_161;
 }
-lean_ctor_set(x_148, 0, x_145);
-lean_ctor_set(x_148, 1, x_134);
-lean_ctor_set(x_148, 2, x_135);
-lean_ctor_set(x_148, 3, x_136);
-lean_ctor_set_uint8(x_148, sizeof(void*)*4, x_77);
-x_149 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_149, 0, x_147);
-lean_ctor_set(x_149, 1, x_143);
-lean_ctor_set(x_149, 2, x_144);
-lean_ctor_set(x_149, 3, x_148);
-lean_ctor_set_uint8(x_149, sizeof(void*)*4, x_141);
-return x_149;
+lean_ctor_set(x_174, 0, x_170);
+lean_ctor_set(x_174, 1, x_158);
+lean_ctor_set(x_174, 2, x_159);
+lean_ctor_set(x_174, 3, x_160);
+lean_ctor_set_uint8(x_174, sizeof(void*)*4, x_172);
+x_175 = 0;
+x_176 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_176, 0, x_173);
+lean_ctor_set(x_176, 1, x_168);
+lean_ctor_set(x_176, 2, x_169);
+lean_ctor_set(x_176, 3, x_174);
+lean_ctor_set_uint8(x_176, sizeof(void*)*4, x_175);
+return x_176;
 }
 else
 {
-lean_object* x_150; lean_object* x_151; 
-if (lean_is_scalar(x_137)) {
- x_150 = lean_alloc_ctor(1, 4, 1);
+uint8_t x_177; lean_object* x_178; lean_object* x_179; 
+x_177 = 1;
+if (lean_is_scalar(x_161)) {
+ x_178 = lean_alloc_ctor(1, 4, 1);
 } else {
- x_150 = x_137;
+ x_178 = x_161;
 }
-lean_ctor_set(x_150, 0, x_138);
-lean_ctor_set(x_150, 1, x_134);
-lean_ctor_set(x_150, 2, x_135);
-lean_ctor_set(x_150, 3, x_136);
-lean_ctor_set_uint8(x_150, sizeof(void*)*4, x_141);
-x_151 = l_Std_RBNode_balLeft___rarg(x_129, x_130, x_131, x_150);
-return x_151;
+lean_ctor_set(x_178, 0, x_162);
+lean_ctor_set(x_178, 1, x_158);
+lean_ctor_set(x_178, 2, x_159);
+lean_ctor_set(x_178, 3, x_160);
+lean_ctor_set_uint8(x_178, sizeof(void*)*4, x_177);
+x_179 = l_Std_RBNode_balLeft___rarg(x_153, x_154, x_155, x_178);
+return x_179;
 }
 }
 }
@@ -22225,22 +19302,6 @@ return x_151;
 }
 }
 }
-lean_object* l_Std_RBNode_appendTrees___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_appendTrees___main___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_appendTrees___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Std_RBNode_appendTrees___main___rarg(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Std_RBNode_appendTrees(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -22249,205 +19310,230 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_appendTrees___rarg), 2, 0);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_del___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_del_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-if (lean_obj_tag(x_3) == 0)
+if (lean_obj_tag(x_1) == 0)
 {
-lean_dec(x_2);
-lean_dec(x_1);
-return x_3;
-}
-else
-{
-uint8_t x_4; 
-x_4 = !lean_is_exclusive(x_3);
-if (x_4 == 0)
-{
-lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; uint8_t x_10; 
-x_5 = lean_ctor_get(x_3, 0);
-x_6 = lean_ctor_get(x_3, 1);
-x_7 = lean_ctor_get(x_3, 2);
-x_8 = lean_ctor_get(x_3, 3);
-lean_inc(x_1);
-lean_inc(x_6);
-lean_inc(x_2);
-x_9 = lean_apply_2(x_1, x_2, x_6);
-x_10 = lean_unbox(x_9);
-lean_dec(x_9);
-if (x_10 == 0)
-{
-lean_object* x_11; uint8_t x_12; 
-lean_inc(x_1);
-lean_inc(x_2);
-lean_inc(x_6);
-x_11 = lean_apply_2(x_1, x_6, x_2);
-x_12 = lean_unbox(x_11);
-lean_dec(x_11);
-if (x_12 == 0)
-{
-lean_object* x_13; 
-lean_free_object(x_3);
-lean_dec(x_7);
-lean_dec(x_6);
-lean_dec(x_2);
-lean_dec(x_1);
-x_13 = l_Std_RBNode_appendTrees___main___rarg(x_5, x_8);
-return x_13;
-}
-else
-{
-uint8_t x_14; 
-x_14 = l_Std_RBNode_isBlack___rarg(x_8);
-if (x_14 == 0)
-{
-lean_object* x_15; uint8_t x_16; 
-x_15 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_8);
-x_16 = 0;
-lean_ctor_set(x_3, 3, x_15);
-lean_ctor_set_uint8(x_3, sizeof(void*)*4, x_16);
-return x_3;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; 
-lean_free_object(x_3);
-x_17 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_8);
-x_18 = l_Std_RBNode_balRight___rarg(x_5, x_6, x_7, x_17);
-return x_18;
-}
-}
-}
-else
-{
-uint8_t x_19; 
-x_19 = l_Std_RBNode_isBlack___rarg(x_5);
-if (x_19 == 0)
-{
-lean_object* x_20; uint8_t x_21; 
-x_20 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_5);
-x_21 = 0;
-lean_ctor_set(x_3, 0, x_20);
-lean_ctor_set_uint8(x_3, sizeof(void*)*4, x_21);
-return x_3;
-}
-else
-{
-lean_object* x_22; lean_object* x_23; 
-lean_free_object(x_3);
-x_22 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_5);
-x_23 = l_Std_RBNode_balLeft___rarg(x_22, x_6, x_7, x_8);
-return x_23;
-}
-}
-}
-else
-{
-lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; 
-x_24 = lean_ctor_get(x_3, 0);
-x_25 = lean_ctor_get(x_3, 1);
-x_26 = lean_ctor_get(x_3, 2);
-x_27 = lean_ctor_get(x_3, 3);
-lean_inc(x_27);
-lean_inc(x_26);
-lean_inc(x_25);
-lean_inc(x_24);
+lean_object* x_4; lean_object* x_5; 
 lean_dec(x_3);
-lean_inc(x_1);
-lean_inc(x_25);
-lean_inc(x_2);
-x_28 = lean_apply_2(x_1, x_2, x_25);
-x_29 = lean_unbox(x_28);
-lean_dec(x_28);
-if (x_29 == 0)
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
 {
-lean_object* x_30; uint8_t x_31; 
-lean_inc(x_1);
-lean_inc(x_2);
-lean_inc(x_25);
-x_30 = lean_apply_2(x_1, x_25, x_2);
-x_31 = lean_unbox(x_30);
-lean_dec(x_30);
-if (x_31 == 0)
-{
-lean_object* x_32; 
-lean_dec(x_26);
-lean_dec(x_25);
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
 lean_dec(x_2);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
 lean_dec(x_1);
-x_32 = l_Std_RBNode_appendTrees___main___rarg(x_24, x_27);
-return x_32;
-}
-else
-{
-uint8_t x_33; 
-x_33 = l_Std_RBNode_isBlack___rarg(x_27);
-if (x_33 == 0)
-{
-lean_object* x_34; uint8_t x_35; lean_object* x_36; 
-x_34 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_27);
-x_35 = 0;
-x_36 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_36, 0, x_24);
-lean_ctor_set(x_36, 1, x_25);
-lean_ctor_set(x_36, 2, x_26);
-lean_ctor_set(x_36, 3, x_34);
-lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_35);
-return x_36;
-}
-else
-{
-lean_object* x_37; lean_object* x_38; 
-x_37 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_27);
-x_38 = l_Std_RBNode_balRight___rarg(x_24, x_25, x_26, x_37);
-return x_38;
+x_11 = lean_box(x_6);
+x_12 = lean_apply_5(x_3, x_11, x_7, x_8, x_9, x_10);
+return x_12;
 }
 }
 }
-else
-{
-uint8_t x_39; 
-x_39 = l_Std_RBNode_isBlack___rarg(x_24);
-if (x_39 == 0)
-{
-lean_object* x_40; uint8_t x_41; lean_object* x_42; 
-x_40 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_24);
-x_41 = 0;
-x_42 = lean_alloc_ctor(1, 4, 1);
-lean_ctor_set(x_42, 0, x_40);
-lean_ctor_set(x_42, 1, x_25);
-lean_ctor_set(x_42, 2, x_26);
-lean_ctor_set(x_42, 3, x_27);
-lean_ctor_set_uint8(x_42, sizeof(void*)*4, x_41);
-return x_42;
-}
-else
-{
-lean_object* x_43; lean_object* x_44; 
-x_43 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_24);
-x_44 = l_Std_RBNode_balLeft___rarg(x_43, x_25, x_26, x_27);
-return x_44;
-}
-}
-}
-}
-}
-}
-lean_object* l_Std_RBNode_del___main(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_del_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_del___main___rarg), 3, 0);
-return x_3;
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_del_match__1___rarg), 3, 0);
+return x_4;
 }
 }
 lean_object* l_Std_RBNode_del___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; 
-x_4 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_3);
+lean_dec(x_2);
+lean_dec(x_1);
+x_4 = lean_box(0);
 return x_4;
 }
+else
+{
+uint8_t x_5; 
+x_5 = !lean_is_exclusive(x_3);
+if (x_5 == 0)
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; uint8_t x_11; 
+x_6 = lean_ctor_get(x_3, 0);
+x_7 = lean_ctor_get(x_3, 1);
+x_8 = lean_ctor_get(x_3, 2);
+x_9 = lean_ctor_get(x_3, 3);
+lean_inc(x_1);
+lean_inc(x_7);
+lean_inc(x_2);
+x_10 = lean_apply_2(x_1, x_2, x_7);
+x_11 = lean_unbox(x_10);
+lean_dec(x_10);
+if (x_11 == 0)
+{
+lean_object* x_12; uint8_t x_13; 
+lean_inc(x_1);
+lean_inc(x_2);
+lean_inc(x_7);
+x_12 = lean_apply_2(x_1, x_7, x_2);
+x_13 = lean_unbox(x_12);
+lean_dec(x_12);
+if (x_13 == 0)
+{
+lean_object* x_14; 
+lean_free_object(x_3);
+lean_dec(x_8);
+lean_dec(x_7);
+lean_dec(x_2);
+lean_dec(x_1);
+x_14 = l_Std_RBNode_appendTrees___rarg(x_6, x_9);
+return x_14;
+}
+else
+{
+uint8_t x_15; 
+x_15 = l_Std_RBNode_isBlack___rarg(x_9);
+if (x_15 == 0)
+{
+lean_object* x_16; uint8_t x_17; 
+x_16 = l_Std_RBNode_del___rarg(x_1, x_2, x_9);
+x_17 = 0;
+lean_ctor_set(x_3, 3, x_16);
+lean_ctor_set_uint8(x_3, sizeof(void*)*4, x_17);
+return x_3;
+}
+else
+{
+lean_object* x_18; lean_object* x_19; 
+lean_free_object(x_3);
+x_18 = l_Std_RBNode_del___rarg(x_1, x_2, x_9);
+x_19 = l_Std_RBNode_balRight___rarg(x_6, x_7, x_8, x_18);
+return x_19;
+}
+}
+}
+else
+{
+uint8_t x_20; 
+x_20 = l_Std_RBNode_isBlack___rarg(x_6);
+if (x_20 == 0)
+{
+lean_object* x_21; uint8_t x_22; 
+x_21 = l_Std_RBNode_del___rarg(x_1, x_2, x_6);
+x_22 = 0;
+lean_ctor_set(x_3, 0, x_21);
+lean_ctor_set_uint8(x_3, sizeof(void*)*4, x_22);
+return x_3;
+}
+else
+{
+lean_object* x_23; lean_object* x_24; 
+lean_free_object(x_3);
+x_23 = l_Std_RBNode_del___rarg(x_1, x_2, x_6);
+x_24 = l_Std_RBNode_balLeft___rarg(x_23, x_7, x_8, x_9);
+return x_24;
+}
+}
+}
+else
+{
+lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; 
+x_25 = lean_ctor_get(x_3, 0);
+x_26 = lean_ctor_get(x_3, 1);
+x_27 = lean_ctor_get(x_3, 2);
+x_28 = lean_ctor_get(x_3, 3);
+lean_inc(x_28);
+lean_inc(x_27);
+lean_inc(x_26);
+lean_inc(x_25);
+lean_dec(x_3);
+lean_inc(x_1);
+lean_inc(x_26);
+lean_inc(x_2);
+x_29 = lean_apply_2(x_1, x_2, x_26);
+x_30 = lean_unbox(x_29);
+lean_dec(x_29);
+if (x_30 == 0)
+{
+lean_object* x_31; uint8_t x_32; 
+lean_inc(x_1);
+lean_inc(x_2);
+lean_inc(x_26);
+x_31 = lean_apply_2(x_1, x_26, x_2);
+x_32 = lean_unbox(x_31);
+lean_dec(x_31);
+if (x_32 == 0)
+{
+lean_object* x_33; 
+lean_dec(x_27);
+lean_dec(x_26);
+lean_dec(x_2);
+lean_dec(x_1);
+x_33 = l_Std_RBNode_appendTrees___rarg(x_25, x_28);
+return x_33;
+}
+else
+{
+uint8_t x_34; 
+x_34 = l_Std_RBNode_isBlack___rarg(x_28);
+if (x_34 == 0)
+{
+lean_object* x_35; uint8_t x_36; lean_object* x_37; 
+x_35 = l_Std_RBNode_del___rarg(x_1, x_2, x_28);
+x_36 = 0;
+x_37 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_37, 0, x_25);
+lean_ctor_set(x_37, 1, x_26);
+lean_ctor_set(x_37, 2, x_27);
+lean_ctor_set(x_37, 3, x_35);
+lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36);
+return x_37;
+}
+else
+{
+lean_object* x_38; lean_object* x_39; 
+x_38 = l_Std_RBNode_del___rarg(x_1, x_2, x_28);
+x_39 = l_Std_RBNode_balRight___rarg(x_25, x_26, x_27, x_38);
+return x_39;
+}
+}
+}
+else
+{
+uint8_t x_40; 
+x_40 = l_Std_RBNode_isBlack___rarg(x_25);
+if (x_40 == 0)
+{
+lean_object* x_41; uint8_t x_42; lean_object* x_43; 
+x_41 = l_Std_RBNode_del___rarg(x_1, x_2, x_25);
+x_42 = 0;
+x_43 = lean_alloc_ctor(1, 4, 1);
+lean_ctor_set(x_43, 0, x_41);
+lean_ctor_set(x_43, 1, x_26);
+lean_ctor_set(x_43, 2, x_27);
+lean_ctor_set(x_43, 3, x_28);
+lean_ctor_set_uint8(x_43, sizeof(void*)*4, x_42);
+return x_43;
+}
+else
+{
+lean_object* x_44; lean_object* x_45; 
+x_44 = l_Std_RBNode_del___rarg(x_1, x_2, x_25);
+x_45 = l_Std_RBNode_balLeft___rarg(x_44, x_26, x_27, x_28);
+return x_45;
+}
+}
+}
+}
+}
 }
 lean_object* l_Std_RBNode_del(lean_object* x_1, lean_object* x_2) {
 _start:
@@ -22461,7 +19547,7 @@ lean_object* l_Std_RBNode_erase___rarg(lean_object* x_1, lean_object* x_2, lean_
 _start:
 {
 lean_object* x_4; lean_object* x_5; 
-x_4 = l_Std_RBNode_del___main___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_del___rarg(x_1, x_2, x_3);
 x_5 = l_Std_RBNode_setBlack___rarg(x_4);
 return x_5;
 }
@@ -22474,7 +19560,45 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_erase___rarg), 3, 0);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_findCore___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_findCore_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_4);
+x_5 = lean_apply_1(x_3, x_2);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_3);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_6(x_4, x_11, x_7, x_8, x_9, x_10, x_2);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_findCore_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_findCore_match__1___rarg), 4, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_findCore___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -22545,22 +19669,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_findCore___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_findCore___main___rarg), 3, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_findCore___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
-_start:
-{
-lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___rarg(x_1, x_2, x_3);
-return x_4;
-}
-}
 lean_object* l_Std_RBNode_findCore(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -22569,7 +19677,45 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBNode_findCore___rarg), 3, 0);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_find___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_find_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_5; 
+lean_dec(x_4);
+x_5 = lean_apply_1(x_3, x_2);
+return x_5;
+}
+else
+{
+uint8_t x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; 
+lean_dec(x_3);
+x_6 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_7 = lean_ctor_get(x_1, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_1, 1);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 2);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 3);
+lean_inc(x_10);
+lean_dec(x_1);
+x_11 = lean_box(x_6);
+x_12 = lean_apply_6(x_4, x_11, x_7, x_8, x_9, x_10, x_2);
+return x_12;
+}
+}
+}
+lean_object* l_Std_RBNode_find_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_find_match__1___rarg), 4, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_find___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -22637,22 +19783,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_find___main(lean_object* x_1) {
-_start:
-{
-lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___main___rarg), 4, 0);
-return x_2;
-}
-}
-lean_object* l_Std_RBNode_find___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Std_RBNode_find___main___rarg(x_1, lean_box(0), x_3, x_4);
-return x_5;
-}
-}
 lean_object* l_Std_RBNode_find(lean_object* x_1) {
 _start:
 {
@@ -22661,7 +19791,45 @@ x_2 = lean_alloc_closure((void*)(l_Std_RBNode_find___rarg), 4, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_lowerBound___main___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_lowerBound_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_6; 
+lean_dec(x_5);
+x_6 = lean_apply_2(x_4, x_2, x_3);
+return x_6;
+}
+else
+{
+uint8_t x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; lean_object* x_13; 
+lean_dec(x_4);
+x_7 = lean_ctor_get_uint8(x_1, sizeof(void*)*4);
+x_8 = lean_ctor_get(x_1, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_1, 1);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_1, 2);
+lean_inc(x_10);
+x_11 = lean_ctor_get(x_1, 3);
+lean_inc(x_11);
+lean_dec(x_1);
+x_12 = lean_box(x_7);
+x_13 = lean_apply_7(x_5, x_12, x_8, x_9, x_10, x_11, x_2, x_3);
+return x_13;
+}
+}
+}
+lean_object* l_Std_RBNode_lowerBound_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_lowerBound_match__1___rarg), 5, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBNode_lowerBound___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -22736,22 +19904,6 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_lowerBound___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_lowerBound___main___rarg), 4, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBNode_lowerBound___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
-_start:
-{
-lean_object* x_5; 
-x_5 = l_Std_RBNode_lowerBound___main___rarg(x_1, x_2, x_3, x_4);
-return x_5;
-}
-}
 lean_object* l_Std_RBNode_lowerBound(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -22794,7 +19946,7 @@ lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_HasEmptyc(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_Std_Data_RBMap___instance__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
@@ -22802,11 +19954,11 @@ x_4 = lean_box(0);
 return x_4;
 }
 }
-lean_object* l_Std_HasEmptyc___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_Std_Data_RBMap___instance__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_HasEmptyc(x_1, x_2, x_3);
+x_4 = l_Std_Std_Data_RBMap___instance__1(x_1, x_2, x_3);
 lean_dec(x_3);
 return x_4;
 }
@@ -22815,7 +19967,7 @@ lean_object* l_Std_RBMap_depth___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_depth___main___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_depth___rarg(x_1, x_2);
 return x_3;
 }
 }
@@ -22845,11 +19997,36 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_fold_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, x_2, lean_box(0));
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_fold_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = lean_alloc_closure((void*)(l_Std_RBMap_fold_match__1___rarg), 3, 0);
+return x_6;
+}
+}
+lean_object* l_Std_RBMap_fold_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Std_RBMap_fold_match__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+return x_6;
+}
+}
 lean_object* l_Std_RBMap_fold___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_fold___main___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_fold___rarg(x_1, x_2, x_3);
 return x_4;
 }
 }
@@ -22870,11 +20047,36 @@ lean_dec(x_4);
 return x_5;
 }
 }
+lean_object* l_Std_RBMap_revFold_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, x_2, lean_box(0));
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_revFold_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = lean_alloc_closure((void*)(l_Std_RBMap_revFold_match__1___rarg), 3, 0);
+return x_6;
+}
+}
+lean_object* l_Std_RBMap_revFold_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Std_RBMap_revFold_match__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+return x_6;
+}
+}
 lean_object* l_Std_RBMap_revFold___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_revFold___main___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_revFold___rarg(x_1, x_2, x_3);
 return x_4;
 }
 }
@@ -22895,11 +20097,36 @@ lean_dec(x_4);
 return x_5;
 }
 }
+lean_object* l_Std_RBMap_foldM_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, x_2, lean_box(0));
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_foldM_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = lean_alloc_closure((void*)(l_Std_RBMap_foldM_match__1___rarg), 3, 0);
+return x_6;
+}
+}
+lean_object* l_Std_RBMap_foldM_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) {
+_start:
+{
+lean_object* x_6; 
+x_6 = l_Std_RBMap_foldM_match__1(x_1, x_2, x_3, x_4, x_5);
+lean_dec(x_4);
+return x_6;
+}
+}
 lean_object* l_Std_RBMap_foldM___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___rarg(x_1, x_2, x_3, x_4);
+x_5 = l_Std_RBNode_foldM___rarg(x_1, x_2, x_3, x_4);
 return x_5;
 }
 }
@@ -22920,21 +20147,21 @@ lean_dec(x_4);
 return x_6;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
+x_5 = l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
 lean_object* x_8; lean_object* x_9; lean_object* x_10; 
 lean_inc(x_1);
 x_8 = lean_apply_2(x_1, x_2, x_3);
-x_9 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__1), 4, 3);
+x_9 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__1), 4, 3);
 lean_closure_set(x_9, 0, x_4);
 lean_closure_set(x_9, 1, x_1);
 lean_closure_set(x_9, 2, x_5);
@@ -22942,7 +20169,7 @@ x_10 = lean_apply_4(x_6, lean_box(0), lean_box(0), x_8, x_9);
 return x_10;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___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)
@@ -22974,9 +20201,9 @@ x_12 = lean_ctor_get(x_1, 1);
 lean_inc(x_12);
 lean_inc(x_2);
 lean_inc(x_1);
-x_13 = l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg(x_1, x_2, x_3, x_8);
+x_13 = l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg(x_1, x_2, x_3, x_8);
 lean_inc(x_12);
-x_14 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__2___boxed), 7, 6);
+x_14 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__2___boxed), 7, 6);
 lean_closure_set(x_14, 0, x_2);
 lean_closure_set(x_14, 1, x_9);
 lean_closure_set(x_14, 2, x_10);
@@ -22988,11 +20215,11 @@ return x_15;
 }
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg), 4, 0);
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg), 4, 0);
 return x_4;
 }
 }
@@ -23001,7 +20228,7 @@ _start:
 {
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_box(0);
-x_5 = l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
+x_5 = l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
 return x_5;
 }
 }
@@ -23013,11 +20240,11 @@ x_5 = lean_alloc_closure((void*)(l_Std_RBMap_forM___rarg), 3, 0);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) {
 _start:
 {
 lean_object* x_8; 
-x_8 = l_Std_RBNode_foldM___main___at_Std_RBMap_forM___spec__1___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
+x_8 = l_Std_RBNode_foldM___at_Std_RBMap_forM___spec__1___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7);
 lean_dec(x_7);
 return x_8;
 }
@@ -23031,6 +20258,42 @@ lean_dec(x_3);
 return x_5;
 }
 }
+lean_object* l_Std_RBMap_isEmpty_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; 
+lean_dec(x_3);
+x_4 = lean_apply_1(x_2, lean_box(0));
+return x_4;
+}
+else
+{
+lean_object* x_5; 
+lean_dec(x_2);
+x_5 = lean_apply_1(x_3, x_1);
+return x_5;
+}
+}
+}
+lean_object* l_Std_RBMap_isEmpty_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_isEmpty_match__1___rarg), 3, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_isEmpty_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_isEmpty_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 uint8_t l_Std_RBMap_isEmpty___rarg(lean_object* x_1) {
 _start:
 {
@@ -23075,6 +20338,31 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_toList_match__1___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_RBMap_toList_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_toList_match__1___rarg), 2, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_toList_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_toList_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_toList___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -23102,7 +20390,7 @@ _start:
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = lean_box(0);
 x_3 = l_Std_RBMap_toList___rarg___closed__1;
-x_4 = l_Std_RBNode_revFold___main___rarg(x_3, x_2, x_1);
+x_4 = l_Std_RBNode_revFold___rarg(x_3, x_2, x_1);
 return x_4;
 }
 }
@@ -23123,11 +20411,72 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_min_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+lean_dec(x_6);
+x_9 = lean_apply_2(x_2, x_7, x_8);
+return x_9;
+}
+}
+}
+lean_object* l_Std_RBMap_min_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBMap_min_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_min_match__2___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_RBMap_min_match__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_min_match__2___rarg), 2, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_min_match__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_min_match__2(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_min___rarg(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Std_RBNode_min___main___rarg(x_1);
+x_2 = l_Std_RBNode_min___rarg(x_1);
 if (lean_obj_tag(x_2) == 0)
 {
 lean_object* x_3; 
@@ -23200,11 +20549,72 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_max_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_ctor_get(x_6, 0);
+lean_inc(x_7);
+x_8 = lean_ctor_get(x_6, 1);
+lean_inc(x_8);
+lean_dec(x_6);
+x_9 = lean_apply_2(x_2, x_7, x_8);
+return x_9;
+}
+}
+}
+lean_object* l_Std_RBMap_max_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBMap_max_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_max_match__2___rarg(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_apply_2(x_2, x_1, lean_box(0));
+return x_3;
+}
+}
+lean_object* l_Std_RBMap_max_match__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_max_match__2___rarg), 2, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_max_match__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_max_match__2(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_max___rarg(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = l_Std_RBNode_max___main___rarg(x_1);
+x_2 = l_Std_RBNode_max___rarg(x_1);
 if (lean_obj_tag(x_2) == 0)
 {
 lean_object* x_3; 
@@ -23277,7 +20687,7 @@ lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4) {
+lean_object* l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg(lean_object* x_1, lean_object* x_2, uint8_t x_3, lean_object* x_4) {
 _start:
 {
 if (x_3 == 0)
@@ -23300,7 +20710,7 @@ lean_inc(x_7);
 lean_dec(x_4);
 lean_inc(x_2);
 lean_inc(x_1);
-x_8 = l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg(x_1, x_2, x_3, x_7);
+x_8 = l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg(x_1, x_2, x_3, x_7);
 x_9 = lean_ctor_get(x_6, 0);
 lean_inc(x_9);
 x_10 = lean_ctor_get(x_6, 1);
@@ -23345,7 +20755,7 @@ lean_dec(x_4);
 x_25 = 0;
 lean_inc(x_2);
 lean_inc(x_1);
-x_26 = l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg(x_1, x_2, x_25, x_24);
+x_26 = l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg(x_1, x_2, x_25, x_24);
 x_27 = lean_ctor_get(x_23, 0);
 lean_inc(x_27);
 x_28 = lean_ctor_get(x_23, 1);
@@ -23369,15 +20779,15 @@ return x_38;
 }
 }
 }
-lean_object* l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2(lean_object* x_1, lean_object* x_2) {
+lean_object* l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg___boxed), 4, 0);
+x_3 = lean_alloc_closure((void*)(l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg___boxed), 4, 0);
 return x_3;
 }
 }
-lean_object* l_List_repr___at_Std_RBMap_HasRepr___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_List_repr___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -23392,7 +20802,7 @@ else
 {
 uint8_t x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
 x_5 = 1;
-x_6 = l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg(x_1, x_2, x_5, x_3);
+x_6 = l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg(x_1, x_2, x_5, x_3);
 x_7 = l_List_repr___rarg___closed__2;
 x_8 = lean_string_append(x_7, x_6);
 lean_dec(x_6);
@@ -23402,15 +20812,15 @@ return x_10;
 }
 }
 }
-lean_object* l_List_repr___at_Std_RBMap_HasRepr___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_List_repr___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_List_repr___at_Std_RBMap_HasRepr___spec__1___rarg), 3, 0);
+x_3 = lean_alloc_closure((void*)(l_List_repr___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__1___rarg), 3, 0);
 return x_3;
 }
 }
-static lean_object* _init_l_Std_RBMap_HasRepr___rarg___closed__1() {
+static lean_object* _init_l_Std_RBMap_Std_Data_RBMap___instance__2___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; 
@@ -23418,45 +20828,70 @@ x_1 = lean_mk_string("rbmapOf ");
 return x_1;
 }
 }
-lean_object* l_Std_RBMap_HasRepr___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBMap_Std_Data_RBMap___instance__2___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_4 = l_Std_RBMap_toList___rarg(x_3);
-x_5 = l_List_repr___at_Std_RBMap_HasRepr___spec__1___rarg(x_1, x_2, x_4);
-x_6 = l_Std_RBMap_HasRepr___rarg___closed__1;
+x_5 = l_List_repr___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__1___rarg(x_1, x_2, x_4);
+x_6 = l_Std_RBMap_Std_Data_RBMap___instance__2___rarg___closed__1;
 x_7 = lean_string_append(x_6, x_5);
 lean_dec(x_5);
 return x_7;
 }
 }
-lean_object* l_Std_RBMap_HasRepr(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBMap_Std_Data_RBMap___instance__2(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Std_RBMap_HasRepr___rarg), 3, 0);
+x_4 = lean_alloc_closure((void*)(l_Std_RBMap_Std_Data_RBMap___instance__2___rarg), 3, 0);
 return x_4;
 }
 }
-lean_object* l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___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_3);
 lean_dec(x_3);
-x_6 = l_List_reprAux___main___at_Std_RBMap_HasRepr___spec__2___rarg(x_1, x_2, x_5, x_4);
+x_6 = l_List_reprAux___main___at_Std_RBMap_Std_Data_RBMap___instance__2___spec__2___rarg(x_1, x_2, x_5, x_4);
 return x_6;
 }
 }
-lean_object* l_Std_RBMap_HasRepr___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBMap_Std_Data_RBMap___instance__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBMap_HasRepr(x_1, x_2, x_3);
+x_4 = l_Std_RBMap_Std_Data_RBMap___instance__2(x_1, x_2, x_3);
 lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_insert_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_apply_4(x_4, x_1, lean_box(0), x_2, x_3);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_insert_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_insert_match__1___rarg), 4, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_insert_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_insert_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_insert___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
@@ -23473,6 +20908,31 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBMap_insert___rarg), 4, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBMap_erase_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, lean_box(0), x_2);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_erase_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_erase_match__1___rarg), 3, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_erase_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_erase_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_erase___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
@@ -23489,7 +20949,45 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBMap_erase___rarg), 3, 0);
 return x_3;
 }
 }
-lean_object* l_Std_RBMap_ofList___main___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBMap_ofList_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_3);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_2, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; 
+lean_dec(x_2);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+x_7 = lean_ctor_get(x_1, 1);
+lean_inc(x_7);
+lean_dec(x_1);
+x_8 = lean_ctor_get(x_6, 0);
+lean_inc(x_8);
+x_9 = lean_ctor_get(x_6, 1);
+lean_inc(x_9);
+lean_dec(x_6);
+x_10 = lean_apply_3(x_3, x_8, x_9, x_7);
+return x_10;
+}
+}
+}
+lean_object* l_Std_RBMap_ofList_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBMap_ofList_match__1___rarg), 3, 0);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_ofList___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -23513,28 +21011,12 @@ x_7 = lean_ctor_get(x_4, 1);
 lean_inc(x_7);
 lean_dec(x_4);
 lean_inc(x_1);
-x_8 = l_Std_RBMap_ofList___main___rarg(x_1, x_5);
+x_8 = l_Std_RBMap_ofList___rarg(x_1, x_5);
 x_9 = l_Std_RBNode_insert___rarg(x_1, x_8, x_6, x_7);
 return x_9;
 }
 }
 }
-lean_object* l_Std_RBMap_ofList___main(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBMap_ofList___main___rarg), 2, 0);
-return x_3;
-}
-}
-lean_object* l_Std_RBMap_ofList___rarg(lean_object* x_1, lean_object* x_2) {
-_start:
-{
-lean_object* x_3; 
-x_3 = l_Std_RBMap_ofList___main___rarg(x_1, x_2);
-return x_3;
-}
-}
 lean_object* l_Std_RBMap_ofList(lean_object* x_1, lean_object* x_2) {
 _start:
 {
@@ -23543,11 +21025,36 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBMap_ofList___rarg), 2, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBMap_findCore_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, lean_box(0), x_2);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_findCore_x3f_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_findCore_x3f_match__1___rarg), 3, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_findCore_x3f_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_findCore_x3f_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_findCore_x3f___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_findCore___rarg(x_1, x_2, x_3);
 return x_4;
 }
 }
@@ -23559,11 +21066,36 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBMap_findCore_x3f___rarg), 3, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBMap_find_x3f_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, lean_box(0), x_2);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_find_x3f_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_find_x3f_match__1___rarg), 3, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_find_x3f_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_find_x3f_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_find_x3f___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_find___main___rarg(x_1, lean_box(0), x_2, x_3);
+x_4 = l_Std_RBNode_find___rarg(x_1, lean_box(0), x_2, x_3);
 return x_4;
 }
 }
@@ -23579,7 +21111,7 @@ lean_object* l_Std_RBMap_findD___rarg(lean_object* x_1, lean_object* x_2, lean_o
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_find___main___rarg(x_1, lean_box(0), x_2, x_3);
+x_5 = l_Std_RBNode_find___rarg(x_1, lean_box(0), x_2, x_3);
 if (lean_obj_tag(x_5) == 0)
 {
 lean_inc(x_4);
@@ -23612,12 +21144,37 @@ lean_dec(x_4);
 return x_5;
 }
 }
+lean_object* l_Std_RBMap_lowerBound_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, lean_box(0), x_2);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_lowerBound_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_lowerBound_match__1___rarg), 3, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_lowerBound_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_lowerBound_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 lean_object* l_Std_RBMap_lowerBound___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_box(0);
-x_5 = l_Std_RBNode_lowerBound___main___rarg(x_1, x_2, x_3, x_4);
+x_5 = l_Std_RBNode_lowerBound___rarg(x_1, x_2, x_3, x_4);
 return x_5;
 }
 }
@@ -23633,7 +21190,7 @@ uint8_t l_Std_RBMap_contains___rarg(lean_object* x_1, lean_object* x_2, lean_obj
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_find___main___rarg(x_1, lean_box(0), x_2, x_3);
+x_4 = l_Std_RBNode_find___rarg(x_1, lean_box(0), x_2, x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 uint8_t x_5; 
@@ -23720,11 +21277,36 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBMap_fromList___rarg), 2, 0);
 return x_3;
 }
 }
+lean_object* l_Std_RBMap_all_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, lean_box(0), x_2);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_all_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_all_match__1___rarg), 3, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_all_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_all_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 uint8_t l_Std_RBMap_all___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
-x_3 = l_Std_RBNode_all___main___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_all___rarg(x_2, x_1);
 return x_3;
 }
 }
@@ -23754,11 +21336,36 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_any_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_apply_3(x_3, x_1, lean_box(0), x_2);
+return x_4;
+}
+}
+lean_object* l_Std_RBMap_any_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = lean_alloc_closure((void*)(l_Std_RBMap_any_match__1___rarg), 3, 0);
+return x_5;
+}
+}
+lean_object* l_Std_RBMap_any_match__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+_start:
+{
+lean_object* x_5; 
+x_5 = l_Std_RBMap_any_match__1(x_1, x_2, x_3, x_4);
+lean_dec(x_3);
+return x_5;
+}
+}
 uint8_t l_Std_RBMap_any___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
-x_3 = l_Std_RBNode_any___main___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_any___rarg(x_2, x_1);
 return x_3;
 }
 }
@@ -23788,7 +21395,7 @@ lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -23800,7 +21407,7 @@ else
 lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_3 = lean_ctor_get(x_2, 0);
 x_4 = lean_ctor_get(x_2, 3);
-x_5 = l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(x_1, x_3);
+x_5 = l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(x_1, x_3);
 x_6 = lean_unsigned_to_nat(1u);
 x_7 = lean_nat_add(x_5, x_6);
 lean_dec(x_5);
@@ -23810,11 +21417,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg___boxed), 2, 0);
+x_3 = lean_alloc_closure((void*)(l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg___boxed), 2, 0);
 return x_3;
 }
 }
@@ -23823,7 +21430,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = lean_unsigned_to_nat(0u);
-x_3 = l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(x_2, x_1);
 return x_3;
 }
 }
@@ -23835,11 +21442,11 @@ x_4 = lean_alloc_closure((void*)(l_Std_RBMap_size___rarg___boxed), 1, 0);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_fold___main___at_Std_RBMap_size___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_fold___at_Std_RBMap_size___spec__1___rarg(x_1, x_2);
 lean_dec(x_2);
 return x_3;
 }
@@ -23875,7 +21482,7 @@ _start:
 {
 lean_object* x_2; lean_object* x_3; 
 x_2 = l_Std_RBMap_maxDepth___rarg___closed__1;
-x_3 = l_Std_RBNode_depth___main___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_depth___rarg(x_2, x_1);
 return x_3;
 }
 }
@@ -23905,6 +21512,37 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_min_x21_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Std_RBMap_min_x21_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBMap_min_x21_match__1___rarg), 3, 0);
+return x_4;
+}
+}
 static lean_object* _init_l_Std_RBMap_min_x21___rarg___closed__1() {
 _start:
 {
@@ -23917,96 +21555,63 @@ static lean_object* _init_l_Std_RBMap_min_x21___rarg___closed__2() {
 _start:
 {
 lean_object* x_1; 
-x_1 = lean_mk_string("map is empty");
+x_1 = lean_mk_string("Std.RBMap.min!");
 return x_1;
 }
 }
 static lean_object* _init_l_Std_RBMap_min_x21___rarg___closed__3() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; 
+x_1 = lean_mk_string("map is empty");
+return x_1;
+}
+}
+static lean_object* _init_l_Std_RBMap_min_x21___rarg___closed__4() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Std_RBMap_min_x21___rarg___closed__1;
-x_2 = lean_unsigned_to_nat(306u);
-x_3 = lean_unsigned_to_nat(12u);
-x_4 = l_Std_RBMap_min_x21___rarg___closed__2;
-x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
-return x_5;
+x_2 = l_Std_RBMap_min_x21___rarg___closed__2;
+x_3 = lean_unsigned_to_nat(309u);
+x_4 = lean_unsigned_to_nat(12u);
+x_5 = l_Std_RBMap_min_x21___rarg___closed__3;
+x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
+return x_6;
 }
 }
 lean_object* l_Std_RBMap_min_x21___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_4; lean_object* x_10; 
-x_10 = l_Std_RBNode_min___main___rarg(x_3);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_object* x_11; 
-x_11 = lean_box(0);
-x_4 = x_11;
-goto block_9;
-}
-else
-{
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_10);
-if (x_12 == 0)
-{
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_13 = lean_ctor_get(x_10, 0);
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-x_15 = lean_ctor_get(x_13, 1);
-lean_inc(x_15);
-lean_dec(x_13);
-x_16 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_16, 0, x_14);
-lean_ctor_set(x_16, 1, x_15);
-lean_ctor_set(x_10, 0, x_16);
-x_4 = x_10;
-goto block_9;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_17 = lean_ctor_get(x_10, 0);
-lean_inc(x_17);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_ctor_get(x_17, 1);
-lean_inc(x_19);
-lean_dec(x_17);
-x_20 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_20, 0, x_18);
-lean_ctor_set(x_20, 1, x_19);
-x_21 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_21, 0, x_20);
-x_4 = x_21;
-goto block_9;
-}
-}
-block_9:
-{
+lean_object* x_4; 
+x_4 = l_Std_RBNode_min___rarg(x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
-x_6 = l_Std_RBMap_min_x21___rarg___closed__3;
+x_6 = l_Std_RBMap_min_x21___rarg___closed__4;
 x_7 = lean_panic_fn(x_5, x_6);
 return x_7;
 }
 else
 {
-lean_object* x_8; 
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 lean_dec(x_2);
 lean_dec(x_1);
 x_8 = lean_ctor_get(x_4, 0);
 lean_inc(x_8);
 lean_dec(x_4);
-return x_8;
-}
+x_9 = lean_ctor_get(x_8, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+lean_dec(x_8);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_9);
+lean_ctor_set(x_11, 1, x_10);
+return x_11;
 }
 }
 }
@@ -24036,92 +21641,90 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_max_x21_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Std_RBMap_max_x21_match__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+lean_object* x_4; 
+x_4 = lean_alloc_closure((void*)(l_Std_RBMap_max_x21_match__1___rarg), 3, 0);
+return x_4;
+}
+}
 static lean_object* _init_l_Std_RBMap_max_x21___rarg___closed__1() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; 
+x_1 = lean_mk_string("Std.RBMap.max!");
+return x_1;
+}
+}
+static lean_object* _init_l_Std_RBMap_max_x21___rarg___closed__2() {
+_start:
+{
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Std_RBMap_min_x21___rarg___closed__1;
-x_2 = lean_unsigned_to_nat(311u);
-x_3 = lean_unsigned_to_nat(12u);
-x_4 = l_Std_RBMap_min_x21___rarg___closed__2;
-x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
-return x_5;
+x_2 = l_Std_RBMap_max_x21___rarg___closed__1;
+x_3 = lean_unsigned_to_nat(314u);
+x_4 = lean_unsigned_to_nat(12u);
+x_5 = l_Std_RBMap_min_x21___rarg___closed__3;
+x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
+return x_6;
 }
 }
 lean_object* l_Std_RBMap_max_x21___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
-lean_object* x_4; lean_object* x_10; 
-x_10 = l_Std_RBNode_max___main___rarg(x_3);
-if (lean_obj_tag(x_10) == 0)
-{
-lean_object* x_11; 
-x_11 = lean_box(0);
-x_4 = x_11;
-goto block_9;
-}
-else
-{
-uint8_t x_12; 
-x_12 = !lean_is_exclusive(x_10);
-if (x_12 == 0)
-{
-lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; 
-x_13 = lean_ctor_get(x_10, 0);
-x_14 = lean_ctor_get(x_13, 0);
-lean_inc(x_14);
-x_15 = lean_ctor_get(x_13, 1);
-lean_inc(x_15);
-lean_dec(x_13);
-x_16 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_16, 0, x_14);
-lean_ctor_set(x_16, 1, x_15);
-lean_ctor_set(x_10, 0, x_16);
-x_4 = x_10;
-goto block_9;
-}
-else
-{
-lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; 
-x_17 = lean_ctor_get(x_10, 0);
-lean_inc(x_17);
-lean_dec(x_10);
-x_18 = lean_ctor_get(x_17, 0);
-lean_inc(x_18);
-x_19 = lean_ctor_get(x_17, 1);
-lean_inc(x_19);
-lean_dec(x_17);
-x_20 = lean_alloc_ctor(0, 2, 0);
-lean_ctor_set(x_20, 0, x_18);
-lean_ctor_set(x_20, 1, x_19);
-x_21 = lean_alloc_ctor(1, 1, 0);
-lean_ctor_set(x_21, 0, x_20);
-x_4 = x_21;
-goto block_9;
-}
-}
-block_9:
-{
+lean_object* x_4; 
+x_4 = l_Std_RBNode_max___rarg(x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; lean_object* x_6; lean_object* x_7; 
 x_5 = lean_alloc_ctor(0, 2, 0);
 lean_ctor_set(x_5, 0, x_1);
 lean_ctor_set(x_5, 1, x_2);
-x_6 = l_Std_RBMap_max_x21___rarg___closed__1;
+x_6 = l_Std_RBMap_max_x21___rarg___closed__2;
 x_7 = lean_panic_fn(x_5, x_6);
 return x_7;
 }
 else
 {
-lean_object* x_8; 
+lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; 
 lean_dec(x_2);
 lean_dec(x_1);
 x_8 = lean_ctor_get(x_4, 0);
 lean_inc(x_8);
 lean_dec(x_4);
-return x_8;
-}
+x_9 = lean_ctor_get(x_8, 0);
+lean_inc(x_9);
+x_10 = lean_ctor_get(x_8, 1);
+lean_inc(x_10);
+lean_dec(x_8);
+x_11 = lean_alloc_ctor(0, 2, 0);
+lean_ctor_set(x_11, 0, x_9);
+lean_ctor_set(x_11, 1, x_10);
+return x_11;
 }
 }
 }
@@ -24151,35 +21754,75 @@ lean_dec(x_3);
 return x_4;
 }
 }
+lean_object* l_Std_RBMap_find_x21_match__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+_start:
+{
+if (lean_obj_tag(x_1) == 0)
+{
+lean_object* x_4; lean_object* x_5; 
+lean_dec(x_2);
+x_4 = lean_box(0);
+x_5 = lean_apply_1(x_3, x_4);
+return x_5;
+}
+else
+{
+lean_object* x_6; lean_object* x_7; 
+lean_dec(x_3);
+x_6 = lean_ctor_get(x_1, 0);
+lean_inc(x_6);
+lean_dec(x_1);
+x_7 = lean_apply_1(x_2, x_6);
+return x_7;
+}
+}
+}
+lean_object* l_Std_RBMap_find_x21_match__1(lean_object* x_1, lean_object* x_2) {
+_start:
+{
+lean_object* x_3; 
+x_3 = lean_alloc_closure((void*)(l_Std_RBMap_find_x21_match__1___rarg), 3, 0);
+return x_3;
+}
+}
 static lean_object* _init_l_Std_RBMap_find_x21___rarg___closed__1() {
 _start:
 {
 lean_object* x_1; 
+x_1 = lean_mk_string("Std.RBMap.find!");
+return x_1;
+}
+}
+static lean_object* _init_l_Std_RBMap_find_x21___rarg___closed__2() {
+_start:
+{
+lean_object* x_1; 
 x_1 = lean_mk_string("key is not in the map");
 return x_1;
 }
 }
-static lean_object* _init_l_Std_RBMap_find_x21___rarg___closed__2() {
+static lean_object* _init_l_Std_RBMap_find_x21___rarg___closed__3() {
 _start:
 {
-lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; 
+lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; 
 x_1 = l_Std_RBMap_min_x21___rarg___closed__1;
-x_2 = lean_unsigned_to_nat(316u);
-x_3 = lean_unsigned_to_nat(12u);
-x_4 = l_Std_RBMap_find_x21___rarg___closed__1;
-x_5 = l___private_Init_Util_1__mkPanicMessage(x_1, x_2, x_3, x_4);
-return x_5;
+x_2 = l_Std_RBMap_find_x21___rarg___closed__1;
+x_3 = lean_unsigned_to_nat(319u);
+x_4 = lean_unsigned_to_nat(12u);
+x_5 = l_Std_RBMap_find_x21___rarg___closed__2;
+x_6 = l___private_Init_Util_2__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5);
+return x_6;
 }
 }
 lean_object* l_Std_RBMap_find_x21___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_find___main___rarg(x_1, lean_box(0), x_3, x_4);
+x_5 = l_Std_RBNode_find___rarg(x_1, lean_box(0), x_3, x_4);
 if (lean_obj_tag(x_5) == 0)
 {
 lean_object* x_6; lean_object* x_7; 
-x_6 = l_Std_RBMap_find_x21___rarg___closed__2;
+x_6 = l_Std_RBMap_find_x21___rarg___closed__3;
 x_7 = lean_panic_fn(x_2, x_6);
 return x_7;
 }
@@ -24267,8 +21910,8 @@ if (lean_io_result_is_error(res)) return res;
 lean_dec_ref(res);
 l_Std_RBMap_toList___rarg___closed__1 = _init_l_Std_RBMap_toList___rarg___closed__1();
 lean_mark_persistent(l_Std_RBMap_toList___rarg___closed__1);
-l_Std_RBMap_HasRepr___rarg___closed__1 = _init_l_Std_RBMap_HasRepr___rarg___closed__1();
-lean_mark_persistent(l_Std_RBMap_HasRepr___rarg___closed__1);
+l_Std_RBMap_Std_Data_RBMap___instance__2___rarg___closed__1 = _init_l_Std_RBMap_Std_Data_RBMap___instance__2___rarg___closed__1();
+lean_mark_persistent(l_Std_RBMap_Std_Data_RBMap___instance__2___rarg___closed__1);
 l_Std_RBMap_maxDepth___rarg___closed__1 = _init_l_Std_RBMap_maxDepth___rarg___closed__1();
 lean_mark_persistent(l_Std_RBMap_maxDepth___rarg___closed__1);
 l_Std_RBMap_min_x21___rarg___closed__1 = _init_l_Std_RBMap_min_x21___rarg___closed__1();
@@ -24277,12 +21920,18 @@ l_Std_RBMap_min_x21___rarg___closed__2 = _init_l_Std_RBMap_min_x21___rarg___clos
 lean_mark_persistent(l_Std_RBMap_min_x21___rarg___closed__2);
 l_Std_RBMap_min_x21___rarg___closed__3 = _init_l_Std_RBMap_min_x21___rarg___closed__3();
 lean_mark_persistent(l_Std_RBMap_min_x21___rarg___closed__3);
+l_Std_RBMap_min_x21___rarg___closed__4 = _init_l_Std_RBMap_min_x21___rarg___closed__4();
+lean_mark_persistent(l_Std_RBMap_min_x21___rarg___closed__4);
 l_Std_RBMap_max_x21___rarg___closed__1 = _init_l_Std_RBMap_max_x21___rarg___closed__1();
 lean_mark_persistent(l_Std_RBMap_max_x21___rarg___closed__1);
+l_Std_RBMap_max_x21___rarg___closed__2 = _init_l_Std_RBMap_max_x21___rarg___closed__2();
+lean_mark_persistent(l_Std_RBMap_max_x21___rarg___closed__2);
 l_Std_RBMap_find_x21___rarg___closed__1 = _init_l_Std_RBMap_find_x21___rarg___closed__1();
 lean_mark_persistent(l_Std_RBMap_find_x21___rarg___closed__1);
 l_Std_RBMap_find_x21___rarg___closed__2 = _init_l_Std_RBMap_find_x21___rarg___closed__2();
 lean_mark_persistent(l_Std_RBMap_find_x21___rarg___closed__2);
+l_Std_RBMap_find_x21___rarg___closed__3 = _init_l_Std_RBMap_find_x21___rarg___closed__3();
+lean_mark_persistent(l_Std_RBMap_find_x21___rarg___closed__3);
 return lean_io_result_mk_ok(lean_box(0));
 }
 #ifdef __cplusplus
diff --git a/stage0/stdlib/Std/Data/RBTree.c b/stage0/stdlib/Std/Data/RBTree.c
index d1486c3497..cdaecff18b 100644
--- a/stage0/stdlib/Std/Data/RBTree.c
+++ b/stage0/stdlib/Std/Data/RBTree.c
@@ -13,56 +13,59 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+lean_object* l_Std_RBNode_all___at_Std_RBTree_subset___spec__1(lean_object*);
 lean_object* l_List_repr___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_toList___rarg___closed__1;
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_min___main___rarg(lean_object*);
 lean_object* l_Std_RBTree_all___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_toList___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_max___rarg(lean_object*);
 lean_object* l_Std_RBTree_forM(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_find_x3f___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_mkRBTree(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_subset___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1(lean_object*);
+lean_object* l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_all___at_Std_RBTree_all___spec__1(lean_object*);
 lean_object* l_Std_RBTree_min___rarg(lean_object*);
-lean_object* l_Std_RBNode_revFold___main___at_Std_RBTree_revFold___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_hasEmptyc(lean_object*, lean_object*);
 lean_object* lean_string_append(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_max(lean_object*, lean_object*);
 lean_object* l_Std_RBNode_insert___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_seteq___rarg___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_forM___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_toList___rarg___lambda__1(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_seteq(lean_object*);
-lean_object* l_Std_RBNode_depth___main___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_depth___rarg___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_revFold___rarg(lean_object*, lean_object*, lean_object*);
+uint8_t l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_foldM(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_all___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_revFold___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_toList___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_max___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Std_RBTree_fold___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_find_x3f(lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1(lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_fold___main___at_Std_RBTree_fold___spec__1___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_revFold___at_Std_RBTree_revFold___spec__1(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_depth___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_any___at_Std_RBTree_any___spec__1(lean_object*);
 lean_object* l_Std_RBTree_fold(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_isEmpty(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_ofList___main___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_all(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_revFold___boxed(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_rbtreeOf___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_findCore___main___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_ofList(lean_object*);
-lean_object* l_Std_RBNode_max___main___rarg(lean_object*);
 lean_object* l_Std_RBTree_hasEmptyc___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_min___rarg(lean_object*);
 lean_object* l_Std_RBNode_erase___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_fromList(lean_object*);
 lean_object* l_Std_RBTree_revFold(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_depth___boxed(lean_object*, lean_object*);
@@ -70,7 +73,7 @@ lean_object* l_Std_RBTree_min___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_empty___boxed(lean_object*, lean_object*);
 lean_object* l_Std_rbtreeOf(lean_object*);
 lean_object* l_Std_mkRBTree___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Std_RBTree_fold___spec__1(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_HasRepr___rarg___closed__1;
 lean_object* l_Std_RBTree_max___rarg___boxed(lean_object*);
 lean_object* l_Std_RBTree_any___rarg___boxed(lean_object*, lean_object*);
@@ -82,40 +85,37 @@ lean_object* l_Std_RBTree_insert___rarg(lean_object*, lean_object*, lean_object*
 lean_object* l_Std_RBTree_HasRepr(lean_object*, lean_object*);
 uint8_t l_Std_RBTree_all___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_HasRepr___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_revFold___main___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_depth___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_any___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_min___rarg___boxed(lean_object*);
 lean_object* l_List_foldl___main___at_Std_RBTree_fromList___spec__1(lean_object*);
 lean_object* l_Std_RBTree_any(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_isEmpty___boxed(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg___boxed(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_max___rarg(lean_object*);
 lean_object* l_Std_RBTree_fromList___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*);
+uint8_t l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_foldM___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBTree_seteq___rarg(lean_object*, lean_object*, lean_object*);
-uint8_t l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg(lean_object*, lean_object*);
 uint8_t l_Std_RBTree_subset___rarg(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_findCore___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_HasRepr___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1(lean_object*);
 uint8_t l_Std_RBTree_contains___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_forM___boxed(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBTree_any___rarg(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_fold___at_Std_RBTree_fold___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_List_foldl___main___at_Std_RBTree_fromList___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_erase___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_min(lean_object*, lean_object*);
 lean_object* l_Std_RBTree_fold___rarg(lean_object*, lean_object*, lean_object*);
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1(lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg___boxed(lean_object*, lean_object*);
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*);
+lean_object* l_Std_RBNode_revFold___at_Std_RBTree_revFold___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_erase(lean_object*);
 lean_object* l_Std_RBTree_subset(lean_object*);
 lean_object* l_Std_RBTree_isEmpty___rarg___boxed(lean_object*);
 lean_object* l_Std_RBTree_toList___rarg(lean_object*);
 lean_object* l_Std_RBTree_depth(lean_object*, lean_object*);
-uint8_t l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 lean_object* l_Std_RBTree_contains(lean_object*);
-uint8_t l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg(lean_object*, lean_object*);
-lean_object* l_Std_RBNode_revFold___main___at_Std_RBTree_revFold___spec__1___rarg(lean_object*, lean_object*, lean_object*);
 uint8_t l_Std_RBTree_isEmpty___rarg(lean_object*);
 lean_object* l_Std_RBTree_ofList___main(lean_object*);
 lean_object* l_Std_RBTree_ofList___rarg(lean_object*, lean_object*);
@@ -176,7 +176,7 @@ lean_object* l_Std_RBTree_depth___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = l_Std_RBNode_depth___main___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_depth___rarg(x_1, x_2);
 return x_3;
 }
 }
@@ -206,7 +206,7 @@ lean_dec(x_2);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Std_RBTree_fold___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_fold___at_Std_RBTree_fold___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -225,7 +225,7 @@ x_6 = lean_ctor_get(x_3, 3);
 lean_inc(x_6);
 lean_dec(x_3);
 lean_inc(x_1);
-x_7 = l_Std_RBNode_fold___main___at_Std_RBTree_fold___spec__1___rarg(x_1, x_2, x_4);
+x_7 = l_Std_RBNode_fold___at_Std_RBTree_fold___spec__1___rarg(x_1, x_2, x_4);
 lean_inc(x_1);
 x_8 = lean_apply_2(x_1, x_7, x_5);
 x_2 = x_8;
@@ -234,11 +234,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_fold___main___at_Std_RBTree_fold___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_fold___at_Std_RBTree_fold___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_fold___main___at_Std_RBTree_fold___spec__1___rarg), 3, 0);
+x_3 = lean_alloc_closure((void*)(l_Std_RBNode_fold___at_Std_RBTree_fold___spec__1___rarg), 3, 0);
 return x_3;
 }
 }
@@ -246,7 +246,7 @@ lean_object* l_Std_RBTree_fold___rarg(lean_object* x_1, lean_object* x_2, lean_o
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_fold___main___at_Std_RBTree_fold___spec__1___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_fold___at_Std_RBTree_fold___spec__1___rarg(x_1, x_2, x_3);
 return x_4;
 }
 }
@@ -267,7 +267,7 @@ lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_revFold___main___at_Std_RBTree_revFold___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_revFold___at_Std_RBTree_revFold___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -286,7 +286,7 @@ x_6 = lean_ctor_get(x_3, 3);
 lean_inc(x_6);
 lean_dec(x_3);
 lean_inc(x_1);
-x_7 = l_Std_RBNode_revFold___main___at_Std_RBTree_revFold___spec__1___rarg(x_1, x_2, x_6);
+x_7 = l_Std_RBNode_revFold___at_Std_RBTree_revFold___spec__1___rarg(x_1, x_2, x_6);
 lean_inc(x_1);
 x_8 = lean_apply_2(x_1, x_7, x_5);
 x_2 = x_8;
@@ -295,11 +295,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_revFold___main___at_Std_RBTree_revFold___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_revFold___at_Std_RBTree_revFold___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_revFold___main___at_Std_RBTree_revFold___spec__1___rarg), 3, 0);
+x_3 = lean_alloc_closure((void*)(l_Std_RBNode_revFold___at_Std_RBTree_revFold___spec__1___rarg), 3, 0);
 return x_3;
 }
 }
@@ -307,7 +307,7 @@ lean_object* l_Std_RBTree_revFold___rarg(lean_object* x_1, lean_object* x_2, lea
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_revFold___main___at_Std_RBTree_revFold___spec__1___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_revFold___at_Std_RBTree_revFold___spec__1___rarg(x_1, x_2, x_3);
 return x_4;
 }
 }
@@ -328,21 +328,21 @@ lean_dec(x_3);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg(x_1, x_2, x_4, x_3);
+x_5 = l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg(x_1, x_2, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; lean_object* x_9; 
 lean_inc(x_1);
 x_7 = lean_apply_2(x_1, x_6, x_2);
-x_8 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg___lambda__1), 4, 3);
+x_8 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg___lambda__1), 4, 3);
 lean_closure_set(x_8, 0, x_3);
 lean_closure_set(x_8, 1, x_1);
 lean_closure_set(x_8, 2, x_4);
@@ -350,7 +350,7 @@ x_9 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_7, x_8);
 return x_9;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___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)
@@ -380,9 +380,9 @@ x_11 = lean_ctor_get(x_1, 1);
 lean_inc(x_11);
 lean_inc(x_2);
 lean_inc(x_1);
-x_12 = l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg(x_1, x_2, x_3, x_8);
+x_12 = l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg(x_1, x_2, x_3, x_8);
 lean_inc(x_11);
-x_13 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg___lambda__2), 6, 5);
+x_13 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg___lambda__2), 6, 5);
 lean_closure_set(x_13, 0, x_2);
 lean_closure_set(x_13, 1, x_9);
 lean_closure_set(x_13, 2, x_1);
@@ -393,11 +393,11 @@ return x_14;
 }
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 lean_object* x_4; 
-x_4 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg), 4, 0);
+x_4 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg), 4, 0);
 return x_4;
 }
 }
@@ -405,7 +405,7 @@ lean_object* l_Std_RBTree_foldM___rarg(lean_object* x_1, lean_object* x_2, lean_
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___at_Std_RBTree_foldM___spec__1___rarg(x_1, x_2, x_3, x_4);
+x_5 = l_Std_RBNode_foldM___at_Std_RBTree_foldM___spec__1___rarg(x_1, x_2, x_3, x_4);
 return x_5;
 }
 }
@@ -426,21 +426,21 @@ lean_dec(x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
 _start:
 {
 lean_object* x_5; 
-x_5 = l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
+x_5 = l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
 return x_5;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; lean_object* x_8; lean_object* x_9; 
 lean_inc(x_1);
 x_7 = lean_apply_1(x_1, x_2);
-x_8 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__1), 4, 3);
+x_8 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__1), 4, 3);
 lean_closure_set(x_8, 0, x_3);
 lean_closure_set(x_8, 1, x_1);
 lean_closure_set(x_8, 2, x_4);
@@ -448,7 +448,7 @@ x_9 = lean_apply_4(x_5, lean_box(0), lean_box(0), x_7, x_8);
 return x_9;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___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)
@@ -478,9 +478,9 @@ x_11 = lean_ctor_get(x_1, 1);
 lean_inc(x_11);
 lean_inc(x_2);
 lean_inc(x_1);
-x_12 = l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg(x_1, x_2, x_3, x_8);
+x_12 = l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg(x_1, x_2, x_3, x_8);
 lean_inc(x_11);
-x_13 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__2___boxed), 6, 5);
+x_13 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__2___boxed), 6, 5);
 lean_closure_set(x_13, 0, x_2);
 lean_closure_set(x_13, 1, x_9);
 lean_closure_set(x_13, 2, x_1);
@@ -491,11 +491,11 @@ return x_14;
 }
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 lean_object* x_3; 
-x_3 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg), 4, 0);
+x_3 = lean_alloc_closure((void*)(l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg), 4, 0);
 return x_3;
 }
 }
@@ -504,7 +504,7 @@ _start:
 {
 lean_object* x_4; lean_object* x_5; 
 x_4 = lean_box(0);
-x_5 = l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
+x_5 = l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg(x_1, x_2, x_4, x_3);
 return x_5;
 }
 }
@@ -516,11 +516,11 @@ x_4 = lean_alloc_closure((void*)(l_Std_RBTree_forM___rarg), 3, 0);
 return x_4;
 }
 }
-lean_object* l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
+lean_object* l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) {
 _start:
 {
 lean_object* x_7; 
-x_7 = l_Std_RBNode_foldM___main___at_Std_RBTree_forM___spec__1___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6);
+x_7 = l_Std_RBNode_foldM___at_Std_RBTree_forM___spec__1___rarg___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6);
 lean_dec(x_6);
 return x_7;
 }
@@ -602,7 +602,7 @@ _start:
 lean_object* x_2; lean_object* x_3; lean_object* x_4; 
 x_2 = lean_box(0);
 x_3 = l_Std_RBTree_toList___rarg___closed__1;
-x_4 = l_Std_RBNode_revFold___main___rarg(x_3, x_2, x_1);
+x_4 = l_Std_RBNode_revFold___rarg(x_3, x_2, x_1);
 return x_4;
 }
 }
@@ -636,7 +636,7 @@ lean_object* l_Std_RBTree_min___rarg(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_11; 
-x_11 = l_Std_RBNode_min___main___rarg(x_1);
+x_11 = l_Std_RBNode_min___rarg(x_1);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_object* x_12; 
@@ -753,7 +753,7 @@ lean_object* l_Std_RBTree_max___rarg(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; lean_object* x_11; 
-x_11 = l_Std_RBNode_max___main___rarg(x_1);
+x_11 = l_Std_RBNode_max___rarg(x_1);
 if (lean_obj_tag(x_11) == 0)
 {
 lean_object* x_12; 
@@ -990,7 +990,7 @@ lean_object* l_Std_RBTree_find_x3f___rarg(lean_object* x_1, lean_object* x_2, le
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_findCore___rarg(x_1, x_2, x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 lean_object* x_5; 
@@ -1039,7 +1039,7 @@ uint8_t l_Std_RBTree_contains___rarg(lean_object* x_1, lean_object* x_2, lean_ob
 _start:
 {
 lean_object* x_4; 
-x_4 = l_Std_RBNode_findCore___main___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_findCore___rarg(x_1, x_2, x_3);
 if (lean_obj_tag(x_4) == 0)
 {
 uint8_t x_5; 
@@ -1122,7 +1122,7 @@ x_2 = lean_alloc_closure((void*)(l_Std_RBTree_fromList___rarg), 2, 0);
 return x_2;
 }
 }
-uint8_t l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+uint8_t l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -1159,7 +1159,7 @@ else
 {
 uint8_t x_10; 
 lean_inc(x_1);
-x_10 = l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg(x_1, x_4);
+x_10 = l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg(x_1, x_4);
 if (x_10 == 0)
 {
 uint8_t x_11; 
@@ -1177,11 +1177,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_all___at_Std_RBTree_all___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -1189,7 +1189,7 @@ uint8_t l_Std_RBTree_all___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
-x_3 = l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg(x_2, x_1);
 return x_3;
 }
 }
@@ -1201,11 +1201,11 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBTree_all___rarg___boxed), 2, 0);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_all___main___at_Std_RBTree_all___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_all___at_Std_RBTree_all___spec__1___rarg(x_1, x_2);
 x_4 = lean_box(x_3);
 return x_4;
 }
@@ -1228,7 +1228,7 @@ lean_dec(x_2);
 return x_3;
 }
 }
-uint8_t l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
+uint8_t l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 if (lean_obj_tag(x_2) == 0)
@@ -1256,7 +1256,7 @@ if (x_8 == 0)
 {
 uint8_t x_9; 
 lean_inc(x_1);
-x_9 = l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg(x_1, x_4);
+x_9 = l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg(x_1, x_4);
 if (x_9 == 0)
 {
 x_2 = x_6;
@@ -1283,11 +1283,11 @@ return x_12;
 }
 }
 }
-lean_object* l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_any___at_Std_RBTree_any___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg___boxed), 2, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg___boxed), 2, 0);
 return x_2;
 }
 }
@@ -1295,7 +1295,7 @@ uint8_t l_Std_RBTree_any___rarg(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; 
-x_3 = l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg(x_2, x_1);
+x_3 = l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg(x_2, x_1);
 return x_3;
 }
 }
@@ -1307,11 +1307,11 @@ x_3 = lean_alloc_closure((void*)(l_Std_RBTree_any___rarg___boxed), 2, 0);
 return x_3;
 }
 }
-lean_object* l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
+lean_object* l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2) {
 _start:
 {
 uint8_t x_3; lean_object* x_4; 
-x_3 = l_Std_RBNode_any___main___at_Std_RBTree_any___spec__1___rarg(x_1, x_2);
+x_3 = l_Std_RBNode_any___at_Std_RBTree_any___spec__1___rarg(x_1, x_2);
 x_4 = lean_box(x_3);
 return x_4;
 }
@@ -1334,7 +1334,7 @@ lean_dec(x_2);
 return x_3;
 }
 }
-uint8_t l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+uint8_t l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
 _start:
 {
 if (lean_obj_tag(x_3) == 0)
@@ -1357,7 +1357,7 @@ lean_inc(x_7);
 lean_dec(x_3);
 lean_inc(x_2);
 lean_inc(x_1);
-x_8 = l_Std_RBNode_findCore___main___rarg(x_1, x_2, x_6);
+x_8 = l_Std_RBNode_findCore___rarg(x_1, x_2, x_6);
 if (lean_obj_tag(x_8) == 0)
 {
 uint8_t x_9; 
@@ -1374,7 +1374,7 @@ uint8_t x_10;
 lean_dec(x_8);
 lean_inc(x_2);
 lean_inc(x_1);
-x_10 = l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg(x_1, x_2, x_5);
+x_10 = l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg(x_1, x_2, x_5);
 if (x_10 == 0)
 {
 uint8_t x_11; 
@@ -1393,11 +1393,11 @@ goto _start;
 }
 }
 }
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1(lean_object* x_1) {
+lean_object* l_Std_RBNode_all___at_Std_RBTree_subset___spec__1(lean_object* x_1) {
 _start:
 {
 lean_object* x_2; 
-x_2 = lean_alloc_closure((void*)(l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg___boxed), 3, 0);
+x_2 = lean_alloc_closure((void*)(l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg___boxed), 3, 0);
 return x_2;
 }
 }
@@ -1405,7 +1405,7 @@ uint8_t l_Std_RBTree_subset___rarg(lean_object* x_1, lean_object* x_2, lean_obje
 _start:
 {
 uint8_t x_4; 
-x_4 = l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg(x_1, x_3, x_2);
+x_4 = l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg(x_1, x_3, x_2);
 return x_4;
 }
 }
@@ -1417,11 +1417,11 @@ x_2 = lean_alloc_closure((void*)(l_Std_RBTree_subset___rarg___boxed), 3, 0);
 return x_2;
 }
 }
-lean_object* l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3) {
+lean_object* l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___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_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg(x_1, x_2, x_3);
+x_4 = l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg(x_1, x_2, x_3);
 x_5 = lean_box(x_4);
 return x_5;
 }
@@ -1442,7 +1442,7 @@ uint8_t x_4;
 lean_inc(x_2);
 lean_inc(x_3);
 lean_inc(x_1);
-x_4 = l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg(x_1, x_3, x_2);
+x_4 = l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg(x_1, x_3, x_2);
 if (x_4 == 0)
 {
 uint8_t x_5; 
@@ -1455,7 +1455,7 @@ return x_5;
 else
 {
 uint8_t x_6; 
-x_6 = l_Std_RBNode_all___main___at_Std_RBTree_subset___spec__1___rarg(x_1, x_2, x_3);
+x_6 = l_Std_RBNode_all___at_Std_RBTree_subset___spec__1___rarg(x_1, x_2, x_3);
 return x_6;
 }
 }